From 5e834504ec2a1d8610641e05f426d6246c17b47b Mon Sep 17 00:00:00 2001 From: Andrew Martinez Date: Mon, 12 Oct 2020 16:43:47 -0400 Subject: [PATCH 1/3] adds Edge API routing - adds mocked posture data for identities - refines OS - adds migrations for posture check types --- controller/internal/routes/identity_router.go | 28 ++++ .../routes/posture_check_api_model.go | 97 ++++++++++- .../routes/posture_check_type_api_model.go | 67 ++++++++ .../routes/posture_check_type_router.go | 60 +++++++ controller/model/handlers.go | 2 + controller/model/posture_check_model.go | 70 ++++++-- controller/model/posture_check_model_mac.go | 60 +++++++ controller/model/posture_check_model_os.go | 98 ++++++++++++ .../model/posture_check_model_process.go | 75 +++++++++ .../posture_check_model_windows_domain.go | 60 +++++++ .../model/posture_check_type_handlers.go | 85 ++++++++++ controller/model/posture_check_type_model.go | 82 ++++++++++ controller/persistence/base_entity.go | 1 + controller/persistence/migration_v12.go | 115 +++++++++++++ controller/persistence/migrations.go | 6 +- .../persistence/posture_check,_store.go | 61 +++++-- controller/persistence/posture_check_mac.go | 60 +++++++ controller/persistence/posture_check_os.go | 80 ++++++++++ .../persistence/posture_check_process.go | 58 +++++++ .../persistence/posture_check_type_store.go | 151 ++++++++++++++++++ .../posture_check_windows_domain.go | 43 +++++ controller/persistence/stores.go | 4 + 22 files changed, 1336 insertions(+), 27 deletions(-) create mode 100644 controller/internal/routes/posture_check_type_api_model.go create mode 100644 controller/internal/routes/posture_check_type_router.go create mode 100644 controller/model/posture_check_model_mac.go create mode 100644 controller/model/posture_check_model_os.go create mode 100644 controller/model/posture_check_model_process.go create mode 100644 controller/model/posture_check_model_windows_domain.go create mode 100644 controller/model/posture_check_type_handlers.go create mode 100644 controller/model/posture_check_type_model.go create mode 100644 controller/persistence/migration_v12.go create mode 100644 controller/persistence/posture_check_mac.go create mode 100644 controller/persistence/posture_check_os.go create mode 100644 controller/persistence/posture_check_process.go create mode 100644 controller/persistence/posture_check_type_store.go create mode 100644 controller/persistence/posture_check_windows_domain.go diff --git a/controller/internal/routes/identity_router.go b/controller/internal/routes/identity_router.go index 39691ef05..bb512b93a 100644 --- a/controller/internal/routes/identity_router.go +++ b/controller/internal/routes/identity_router.go @@ -114,6 +114,11 @@ func (r *IdentityRouter) Register(ae *env.AppEnv) { ae.Api.IdentityGetIdentityPolicyAdviceHandler = identity.GetIdentityPolicyAdviceHandlerFunc(func(params identity.GetIdentityPolicyAdviceParams, _ interface{}) middleware.Responder { return ae.IsAllowed(r.getPolicyAdvice, params.HTTPRequest, params.ID, params.ServiceID, permissions.IsAdmin()) }) + + // posture data + ae.Api.IdentityGetIdentityPostureDataHandler = identity.GetIdentityPostureDataHandlerFunc(func(params identity.GetIdentityPostureDataParams, _ interface{}) middleware.Responder { + return ae.IsAllowed(r.getPostureData, params.HTTPRequest, params.ID, "", permissions.IsAdmin()) + }) } func (r *IdentityRouter) List(ae *env.AppEnv, rc *response.RequestContext) { @@ -278,3 +283,26 @@ func (r *IdentityRouter) getPolicyAdvice(ae *env.AppEnv, rc *response.RequestCon output := MapAdvisorServiceReachabilityToRestEntity(result) rc.RespondWithOk(output, nil) } + +func (r *IdentityRouter) getPostureData(_ *env.AppEnv, rc *response.RequestContext) { + rc.RespondWithOk(map[string]interface{}{ + "os": struct { + Type string + Version string + }{ + "Linux", + "4.19", + }, + "domain": struct { + Name string + }{ + "", + }, + "mac": struct { + Addresses []string + }{ + []string{"39979133921d", "e031ca6cd289"}, + }, + "processes": []interface{}{}, + }, nil) +} diff --git a/controller/internal/routes/posture_check_api_model.go b/controller/internal/routes/posture_check_api_model.go index 163ed8b77..dc81c25d3 100644 --- a/controller/internal/routes/posture_check_api_model.go +++ b/controller/internal/routes/posture_check_api_model.go @@ -18,6 +18,7 @@ package routes import ( "fmt" + "github.com/go-openapi/strfmt" "github.com/michaelquigley/pfxlog" "github.com/openziti/edge/controller/env" "github.com/openziti/edge/controller/model" @@ -51,7 +52,41 @@ func MapCreatePostureCheckToModel(postureCheck rest_model.PostureCheckCreate) *m BaseEntity: models.BaseEntity{ Tags: postureCheck.Tags(), }, - Name: stringz.OrEmpty(postureCheck.Name()), + Name: stringz.OrEmpty(postureCheck.Name()), + TypeId: string(postureCheck.TypeID()), + Description: stringz.OrEmpty(postureCheck.Description()), + Version: 1, + } + + switch apiSubType := postureCheck.(type) { + case *rest_model.PostureCheckOperatingSystemCreate: + subType := &model.PostureCheckOperatingSystem{ + OperatingSystems: []model.OperatingSystem{}, + } + + for _, os := range apiSubType.OperatingSystems { + subType.OperatingSystems = append(subType.OperatingSystems, model.OperatingSystem{ + OsType: string(os.Type), + OsVersions: os.Versions, + }) + } + ret.SubType = subType + + case *rest_model.PostureCheckDomainCreate: + ret.SubType = &model.PostureCheckWindowsDomains{ + Domains: apiSubType.Domains, + } + case *rest_model.PostureCheckMacAddressCreate: + ret.SubType = &model.PostureCheckMacAddresses{ + MacAddresses: apiSubType.MacAddresses, + } + case *rest_model.PostureCheckProcessCreate: + ret.SubType = &model.PostureCheckProcess{ + OperatingSystem: string(apiSubType.Process.OsType), + Path: *apiSubType.Process.Path, + Hashes: apiSubType.Process.Hashes, + Fingerprint: apiSubType.Process.SignerFingerprint, + } } return ret @@ -103,5 +138,63 @@ func MapPostureCheckToRestEntity(_ *env.AppEnv, _ *response.RequestContext, e mo } func MapPostureCheckToRestModel(i *model.PostureCheck) (rest_model.PostureCheckDetail, error) { - return nil, nil + var ret rest_model.PostureCheckDetail + + switch subType := i.SubType.(type) { + case *model.PostureCheckOperatingSystem: + osArray := rest_model.OperatingSystemArray{} + + for _, osMatch := range subType.OperatingSystems { + osArray = append(osArray, &rest_model.OperatingSystem{ + Type: rest_model.OsType(osMatch.OsType), + Versions: osMatch.OsVersions, + }) + } + + ret = &rest_model.PostureCheckOperatingSystemDetail{ + OperatingSystems: osArray, + } + + setBaseEntityDetailsOnPostureCheck(ret, i) + + case *model.PostureCheckProcess: + processMatch := &rest_model.Process{ + Hashes: subType.Hashes, + OsType: rest_model.OsType(subType.OperatingSystem), + Path: &subType.Path, + SignerFingerprint: subType.Fingerprint, + } + + ret = &rest_model.PostureCheckProcessDetail{ + Process: processMatch, + } + + setBaseEntityDetailsOnPostureCheck(ret, i) + case *model.PostureCheckWindowsDomains: + ret = &rest_model.PostureCheckDomainDetail{ + Domains: subType.Domains, + } + setBaseEntityDetailsOnPostureCheck(ret, i) + case *model.PostureCheckMacAddresses: + ret = &rest_model.PostureCheckMacAddressDetail{ + MacAddresses: subType.MacAddresses, + } + setBaseEntityDetailsOnPostureCheck(ret, i) + } + + return ret, nil +} + +func setBaseEntityDetailsOnPostureCheck(check rest_model.PostureCheckDetail, i *model.PostureCheck) { + createdAt := strfmt.DateTime(i.CreatedAt) + updatedAt := strfmt.DateTime(i.UpdatedAt) + check.SetCreatedAt(&createdAt) + check.SetUpdatedAt(&updatedAt) + check.SetTags(i.Tags) + check.SetID(&i.Id) + check.SetLinks(PostureCheckLinkFactory.Links(i)) + check.SetDescription(&i.Description) + check.SetName(&i.Name) + check.SetTypeID(i.TypeId) + check.SetVersion(&i.Version) } diff --git a/controller/internal/routes/posture_check_type_api_model.go b/controller/internal/routes/posture_check_type_api_model.go new file mode 100644 index 000000000..63dc6c566 --- /dev/null +++ b/controller/internal/routes/posture_check_type_api_model.go @@ -0,0 +1,67 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package routes + +import ( + "fmt" + "github.com/michaelquigley/pfxlog" + "github.com/openziti/edge/controller/env" + "github.com/openziti/edge/controller/model" + "github.com/openziti/edge/controller/response" + "github.com/openziti/edge/rest_model" + "github.com/openziti/fabric/controller/models" +) + +const EntityNamePostureCheckType = "posture-check-types" + +var PostureCheckTypeLinkFactory = NewBasicLinkFactory(EntityNamePostureCheckType) + +func MapPostureCheckTypeToRestEntity(_ *env.AppEnv, _ *response.RequestContext, postureCheckTypeModel models.Entity) (interface{}, error) { + postureCheckType, ok := postureCheckTypeModel.(*model.PostureCheckType) + + if !ok { + err := fmt.Errorf("entity is not a posture check type \"%s\"", postureCheckTypeModel.GetId()) + log := pfxlog.Logger() + log.Error(err) + return nil, err + } + + restModel := MapPostureCheckTypeToRestModel(postureCheckType) + + return restModel, nil +} + +func MapPostureCheckTypeToRestModel(postureCheckType *model.PostureCheckType) *rest_model.PostureCheckTypeDetail { + + operatingSystems := rest_model.OperatingSystemArray{} + + for _, os := range postureCheckType.OperatingSystems { + + newOs := &rest_model.OperatingSystem{ + Type: rest_model.OsType(os.OsType), + Versions: os.OsVersions, + } + operatingSystems = append(operatingSystems, newOs) + } + + ret := &rest_model.PostureCheckTypeDetail{ + BaseEntity: BaseEntityToRestModel(postureCheckType, PostureCheckTypeLinkFactory), + Name: &postureCheckType.Name, + OperatingSystems: operatingSystems, + } + return ret +} diff --git a/controller/internal/routes/posture_check_type_router.go b/controller/internal/routes/posture_check_type_router.go new file mode 100644 index 000000000..ac2c4f701 --- /dev/null +++ b/controller/internal/routes/posture_check_type_router.go @@ -0,0 +1,60 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package routes + +import ( + "github.com/go-openapi/runtime/middleware" + "github.com/openziti/edge/controller/env" + "github.com/openziti/edge/controller/internal/permissions" + "github.com/openziti/edge/controller/response" + "github.com/openziti/edge/rest_server/operations/posture_checks" +) + +func init() { + r := NewPostureCheckTypeRouter() + env.AddRouter(r) +} + +type PostureCheckTypeRouter struct { + BasePath string +} + +func NewPostureCheckTypeRouter() *PostureCheckTypeRouter { + return &PostureCheckTypeRouter{ + BasePath: "/" + EntityNamePostureCheckType, + } +} + +func (r *PostureCheckTypeRouter) Register(ae *env.AppEnv) { + + ae.Api.PostureChecksDetailPostureCheckTypeHandler = posture_checks.DetailPostureCheckTypeHandlerFunc(func(params posture_checks.DetailPostureCheckTypeParams, _ interface{}) middleware.Responder { + return ae.IsAllowed(r.Detail, params.HTTPRequest, params.ID, "", permissions.IsAdmin()) + }) + + ae.Api.PostureChecksListPostureCheckTypesHandler = posture_checks.ListPostureCheckTypesHandlerFunc(func(params posture_checks.ListPostureCheckTypesParams, _ interface{}) middleware.Responder { + return ae.IsAllowed(r.List, params.HTTPRequest, "", "", permissions.IsAdmin()) + }) + +} + +func (r *PostureCheckTypeRouter) List(ae *env.AppEnv, rc *response.RequestContext) { + ListWithHandler(ae, rc, ae.Handlers.PostureCheckType, MapPostureCheckTypeToRestEntity) +} + +func (r *PostureCheckTypeRouter) Detail(ae *env.AppEnv, rc *response.RequestContext) { + DetailWithHandler(ae, rc, ae.Handlers.PostureCheckType, MapPostureCheckTypeToRestEntity) +} diff --git a/controller/model/handlers.go b/controller/model/handlers.go index 094cdbd33..7b2921428 100644 --- a/controller/model/handlers.go +++ b/controller/model/handlers.go @@ -46,6 +46,7 @@ type Handlers struct { Authenticator *AuthenticatorHandler Enrollment *EnrollmentHandler PostureCheck *PostureCheckHandler + PostureCheckType *PostureCheckTypeHandler } func InitHandlers(env Env) *Handlers { @@ -74,6 +75,7 @@ func InitHandlers(env Env) *Handlers { handlers.Session = NewSessionHandler(env) handlers.TransitRouter = NewTransitRouterHandler(env) handlers.PostureCheck = NewPostureCheckHandler(env) + handlers.PostureCheckType = NewPostureCheckTypeHandler(env) return handlers } diff --git a/controller/model/posture_check_model.go b/controller/model/posture_check_model.go index 8a1f74727..58bac4f99 100644 --- a/controller/model/posture_check_model.go +++ b/controller/model/posture_check_model.go @@ -17,6 +17,7 @@ package model import ( + "fmt" "github.com/openziti/edge/controller/persistence" "github.com/openziti/fabric/controller/models" "github.com/openziti/foundation/storage/boltz" @@ -27,38 +28,83 @@ import ( type PostureCheck struct { models.BaseEntity - Name string + Name string + TypeId string + Description string + Version int64 + SubType PostureCheckSubType } -func (entity *PostureCheck) fillFrom(_ Handler, _ *bbolt.Tx, boltEntity boltz.Entity) error { +type PostureCheckSubType interface { + toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) + toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) + toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) + fillFrom(handler Handler, tx *bbolt.Tx, check *persistence.PostureCheck, subType persistence.PostureCheckSubType) error +} + +type newPostureCheckSubType func() PostureCheckSubType + +var postureCheckSubTypeMap = map[string]newPostureCheckSubType{ + "OS": newPostureCheckOperatingSystem, + "DOMAIN": newPostureCheckWindowsDomains, + "PROCESS": newPostureCheckProcess, + "MAC": newPostureCheckMacAddresses, +} + +func newSubType(typeId string) PostureCheckSubType { + if factory, ok := postureCheckSubTypeMap[typeId]; ok { + return factory() + } + return nil +} + +func (entity *PostureCheck) fillFrom(handler Handler, tx *bbolt.Tx, boltEntity boltz.Entity) error { boltPostureCheck, ok := boltEntity.(*persistence.PostureCheck) if !ok { - return errors.Errorf("unexpected type %v when filling model ca", reflect.TypeOf(boltEntity)) + return errors.Errorf("unexpected type %v when filling model posture check", reflect.TypeOf(boltEntity)) } entity.FillCommon(boltPostureCheck) entity.Name = boltPostureCheck.Name + entity.TypeId = boltPostureCheck.TypeId + entity.Description = boltPostureCheck.Description + entity.Version = boltPostureCheck.Version + + subType := newSubType(entity.TypeId) + + if subType == nil { + return fmt.Errorf("cannot create posture check subtype [%v]", entity.TypeId) + } + + if err := subType.fillFrom(handler, tx, boltPostureCheck, boltPostureCheck.SubType); err != nil { + return fmt.Errorf("error filling posture check subType [%v]: %v", entity.TypeId, err) + } + + entity.SubType = subType + return nil } func (entity *PostureCheck) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (boltz.Entity, error) { - boltEntity := &persistence.PostureCheck{ BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), Name: entity.Name, + TypeId: entity.TypeId, + Description: entity.Description, + Version: 1, + } + + var err error + if boltEntity.SubType, err = entity.SubType.toBoltEntityForCreate(tx, handler); err != nil { + return nil, fmt.Errorf("error converting to bolt posture check subType [%v] for create: %v", entity.TypeId, err) } return boltEntity, nil } -func (entity *PostureCheck) toBoltEntityForUpdate(_ *bbolt.Tx, _ Handler) (boltz.Entity, error) { - boltEntity := &persistence.PostureCheck{ - BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), - Name: entity.Name, - } - - return boltEntity, nil +func (entity *PostureCheck) toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (boltz.Entity, error) { + return entity.toBoltEntityForCreate(tx, handler) } func (entity *PostureCheck) toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (boltz.Entity, error) { - return entity.toBoltEntityForUpdate(tx, handler) + return entity.toBoltEntityForCreate(tx, handler) } diff --git a/controller/model/posture_check_model_mac.go b/controller/model/posture_check_model_mac.go new file mode 100644 index 000000000..2973109dc --- /dev/null +++ b/controller/model/posture_check_model_mac.go @@ -0,0 +1,60 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "fmt" + "github.com/openziti/edge/controller/persistence" + "go.etcd.io/bbolt" +) + +type PostureCheckMacAddresses struct { + MacAddresses []string +} + +func newPostureCheckMacAddresses() PostureCheckSubType { + return &PostureCheckMacAddresses{} +} + +func (p *PostureCheckMacAddresses) fillFrom(handler Handler, tx *bbolt.Tx, check *persistence.PostureCheck, subType persistence.PostureCheckSubType) error { + subCheck := subType.(*persistence.PostureCheckMacAddresses) + + if subCheck == nil { + return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + } + + p.MacAddresses = subCheck.MacAddresses + return nil +} + +func (p *PostureCheckMacAddresses) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckMacAddresses{ + MacAddresses: p.MacAddresses, + }, nil +} + +func (p *PostureCheckMacAddresses) toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckMacAddresses{ + MacAddresses: p.MacAddresses, + }, nil +} + +func (p *PostureCheckMacAddresses) toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckMacAddresses{ + MacAddresses: p.MacAddresses, + }, nil +} diff --git a/controller/model/posture_check_model_os.go b/controller/model/posture_check_model_os.go new file mode 100644 index 000000000..a84cb6d6b --- /dev/null +++ b/controller/model/posture_check_model_os.go @@ -0,0 +1,98 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "fmt" + "github.com/openziti/edge/controller/persistence" + "go.etcd.io/bbolt" +) + +type PostureCheckOperatingSystem struct { + OperatingSystems []OperatingSystem +} + +type OperatingSystem struct { + OsType string + OsVersions []string +} + +func newPostureCheckOperatingSystem() PostureCheckSubType { + return &PostureCheckOperatingSystem{} +} + +func (p *PostureCheckOperatingSystem) fillFrom(handler Handler, tx *bbolt.Tx, check *persistence.PostureCheck, subType persistence.PostureCheckSubType) error { + subCheck := subType.(*persistence.PostureCheckOperatingSystem) + + if subCheck == nil { + return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + } + + for _, osMatch := range subCheck.OperatingSystems { + p.OperatingSystems = append(p.OperatingSystems, OperatingSystem{ + OsType: osMatch.OsType, + OsVersions: osMatch.OsVersions, + }) + } + + return nil +} + +func (p *PostureCheckOperatingSystem) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + ret := &persistence.PostureCheckOperatingSystem{ + OperatingSystems: []persistence.OperatingSystem{}, + } + + for _, osMatch := range p.OperatingSystems { + ret.OperatingSystems = append(ret.OperatingSystems, persistence.OperatingSystem{ + OsType: osMatch.OsType, + OsVersions: osMatch.OsVersions, + }) + } + + return ret, nil +} + +func (p *PostureCheckOperatingSystem) toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + ret := &persistence.PostureCheckOperatingSystem{ + OperatingSystems: []persistence.OperatingSystem{}, + } + + for _, osMatch := range p.OperatingSystems { + ret.OperatingSystems = append(ret.OperatingSystems, persistence.OperatingSystem{ + OsType: osMatch.OsType, + OsVersions: osMatch.OsVersions, + }) + } + + return ret, nil +} + +func (p *PostureCheckOperatingSystem) toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + ret := &persistence.PostureCheckOperatingSystem{ + OperatingSystems: []persistence.OperatingSystem{}, + } + + for _, osMatch := range p.OperatingSystems { + ret.OperatingSystems = append(ret.OperatingSystems, persistence.OperatingSystem{ + OsType: osMatch.OsType, + OsVersions: osMatch.OsVersions, + }) + } + + return ret, nil +} diff --git a/controller/model/posture_check_model_process.go b/controller/model/posture_check_model_process.go new file mode 100644 index 000000000..6108d4ad9 --- /dev/null +++ b/controller/model/posture_check_model_process.go @@ -0,0 +1,75 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "fmt" + "github.com/openziti/edge/controller/persistence" + "go.etcd.io/bbolt" +) + +type PostureCheckProcess struct { + OperatingSystem string + Path string + Hashes []string + Fingerprint string +} + +func newPostureCheckProcess() PostureCheckSubType { + return &PostureCheckProcess{} +} + +func (p *PostureCheckProcess) fillFrom(handler Handler, tx *bbolt.Tx, check *persistence.PostureCheck, subType persistence.PostureCheckSubType) error { + subCheck := subType.(*persistence.PostureCheckProcess) + + if subCheck == nil { + return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + } + + p.OperatingSystem = subCheck.OperatingSystem + p.Path = subCheck.Path + p.Hashes = subCheck.Hashes + p.Fingerprint = subCheck.Fingerprint + return nil +} + +func (p *PostureCheckProcess) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckProcess{ + OperatingSystem: p.OperatingSystem, + Path: p.Path, + Hashes: p.Hashes, + Fingerprint: p.Fingerprint, + }, nil +} + +func (p *PostureCheckProcess) toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckProcess{ + OperatingSystem: p.OperatingSystem, + Path: p.Path, + Hashes: p.Hashes, + Fingerprint: p.Fingerprint, + }, nil +} + +func (p *PostureCheckProcess) toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckProcess{ + OperatingSystem: p.OperatingSystem, + Path: p.Path, + Hashes: p.Hashes, + Fingerprint: p.Fingerprint, + }, nil +} diff --git a/controller/model/posture_check_model_windows_domain.go b/controller/model/posture_check_model_windows_domain.go new file mode 100644 index 000000000..21fd43c0e --- /dev/null +++ b/controller/model/posture_check_model_windows_domain.go @@ -0,0 +1,60 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "fmt" + "github.com/openziti/edge/controller/persistence" + "go.etcd.io/bbolt" +) + +type PostureCheckWindowsDomains struct { + Domains []string +} + +func newPostureCheckWindowsDomains() PostureCheckSubType { + return &PostureCheckWindowsDomains{} +} + +func (p *PostureCheckWindowsDomains) fillFrom(handler Handler, tx *bbolt.Tx, check *persistence.PostureCheck, subType persistence.PostureCheckSubType) error { + subCheck := subType.(*persistence.PostureCheckWindowsDomains) + + if subCheck == nil { + return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + } + + p.Domains = subCheck.Domains + return nil +} + +func (p *PostureCheckWindowsDomains) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckWindowsDomains{ + Domains: p.Domains, + }, nil +} + +func (p *PostureCheckWindowsDomains) toBoltEntityForUpdate(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckWindowsDomains{ + Domains: p.Domains, + }, nil +} + +func (p *PostureCheckWindowsDomains) toBoltEntityForPatch(tx *bbolt.Tx, handler Handler) (persistence.PostureCheckSubType, error) { + return &persistence.PostureCheckWindowsDomains{ + Domains: p.Domains, + }, nil +} diff --git a/controller/model/posture_check_type_handlers.go b/controller/model/posture_check_type_handlers.go new file mode 100644 index 000000000..ed916c289 --- /dev/null +++ b/controller/model/posture_check_type_handlers.go @@ -0,0 +1,85 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "github.com/openziti/foundation/storage/boltz" +) + +func NewPostureCheckTypeHandler(env Env) *PostureCheckTypeHandler { + handler := &PostureCheckTypeHandler{ + baseHandler: newBaseHandler(env, env.GetStores().PostureCheckType), + } + handler.impl = handler + return handler +} + +type PostureCheckTypeHandler struct { + baseHandler +} + +func (handler *PostureCheckTypeHandler) newModelEntity() boltEntitySink { + return &PostureCheckType{} +} + +func (handler *PostureCheckTypeHandler) Create(PostureCheckTypeModel *PostureCheckType) (string, error) { + return handler.createEntity(PostureCheckTypeModel) +} + +func (handler *PostureCheckTypeHandler) Read(id string) (*PostureCheckType, error) { + modelEntity := &PostureCheckType{} + if err := handler.readEntity(id, modelEntity); err != nil { + return nil, err + } + return modelEntity, nil +} + +func (handler *PostureCheckTypeHandler) ReadByIdOrName(idOrName string) (*PostureCheckType, error) { + modelEntity := &PostureCheckType{} + err := handler.readEntity(idOrName, modelEntity) + + if err == nil { + return modelEntity, nil + } + + if !boltz.IsErrNotFoundErr(err) { + return nil, err + } + + if modelEntity.Id == "" { + modelEntity, err = handler.ReadByName(idOrName) + } + + if err != nil { + return nil, err + } + + return modelEntity, nil +} + +func (handler *PostureCheckTypeHandler) Delete(id string) error { + return handler.deleteEntity(id) +} + +func (handler *PostureCheckTypeHandler) ReadByName(name string) (*PostureCheckType, error) { + modelPostureCheckType := &PostureCheckType{} + nameIndex := handler.env.GetStores().PostureCheckType.GetNameIndex() + if err := handler.readEntityWithIndex("name", []byte(name), nameIndex, modelPostureCheckType); err != nil { + return nil, err + } + return modelPostureCheckType, nil +} diff --git a/controller/model/posture_check_type_model.go b/controller/model/posture_check_type_model.go new file mode 100644 index 000000000..0f32eb5e2 --- /dev/null +++ b/controller/model/posture_check_type_model.go @@ -0,0 +1,82 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package model + +import ( + "github.com/openziti/edge/controller/persistence" + "github.com/openziti/fabric/controller/models" + "github.com/openziti/foundation/storage/boltz" + "github.com/pkg/errors" + "go.etcd.io/bbolt" + "reflect" +) + +type PostureCheckType struct { + models.BaseEntity + Name string `json:"name"` + OperatingSystems []OperatingSystem +} + +func (entity *PostureCheckType) toBoltEntity() (boltz.Entity, error) { + var operatingSystems []persistence.OperatingSystem + + for _, os := range entity.OperatingSystems { + operatingSystems = append(operatingSystems, persistence.OperatingSystem{ + OsType: os.OsType, + OsVersions: os.OsVersions, + }) + } + + return &persistence.PostureCheckType{ + Name: entity.Name, + OperatingSystems: operatingSystems, + BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), + }, nil +} + +func (entity *PostureCheckType) toBoltEntityForCreate(*bbolt.Tx, Handler) (boltz.Entity, error) { + return entity.toBoltEntity() +} + +func (entity *PostureCheckType) toBoltEntityForUpdate(*bbolt.Tx, Handler) (boltz.Entity, error) { + return entity.toBoltEntity() +} + +func (entity *PostureCheckType) toBoltEntityForPatch(*bbolt.Tx, Handler) (boltz.Entity, error) { + return entity.toBoltEntity() +} + +func (entity *PostureCheckType) fillFrom(_ Handler, _ *bbolt.Tx, boltEntity boltz.Entity) error { + boltPostureCheckType, ok := boltEntity.(*persistence.PostureCheckType) + if !ok { + return errors.Errorf("unexpected type %v when filling model PostureCheckType", reflect.TypeOf(boltEntity)) + } + + var operatingSystems []OperatingSystem + + for _, os := range boltPostureCheckType.OperatingSystems { + operatingSystems = append(operatingSystems, OperatingSystem{ + OsType: os.OsType, + OsVersions: os.OsVersions, + }) + } + + entity.FillCommon(boltPostureCheckType) + entity.Name = boltPostureCheckType.Name + entity.OperatingSystems = operatingSystems + return nil +} diff --git a/controller/persistence/base_entity.go b/controller/persistence/base_entity.go index c69df47f0..147e7ca8d 100644 --- a/controller/persistence/base_entity.go +++ b/controller/persistence/base_entity.go @@ -38,6 +38,7 @@ const ( EntityTypeEnrollments = "enrollments" EntityTypeAuthenticators = "authenticators" EntityTypePostureChecks = "postureChecks" + EntityTypePostureCheckTypes = "postureCheckTypes" EdgeBucket = "edge" FieldName = "name" diff --git a/controller/persistence/migration_v12.go b/controller/persistence/migration_v12.go new file mode 100644 index 000000000..d786305cd --- /dev/null +++ b/controller/persistence/migration_v12.go @@ -0,0 +1,115 @@ +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" + "time" +) + +func (m *Migrations) addPostureCheckTypes(step *boltz.MigrationStep) { + windows := OperatingSystem{ + OsType: "Windows", + OsVersions: []string{"Vista", "7", "8", "10", "2000"}, + } + + linux := OperatingSystem{ + OsType: "Linux", + OsVersions: []string{"4.14", "4.19", "5.4", "5.9"}, + } + + iOS := OperatingSystem{ + OsType: "iOS", + OsVersions: []string{"11", "12"}, + } + + macOS := OperatingSystem{ + OsType: "macOS", + OsVersions: []string{"10.15", "11.0"}, + } + + android := OperatingSystem{ + OsType: "Android", + OsVersions: []string{"9", "10", "11"}, + } + + allOS := []OperatingSystem{ + windows, + linux, + android, + macOS, + iOS, + } + + types := []*PostureCheckType{ + { + BaseExtEntity: boltz.BaseExtEntity{ + Id: "OS", + ExtEntityFields: boltz.ExtEntityFields{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + Tags: map[string]interface{}{}, + Migrate: false, + }, + }, + Name: "Operating System Check", + OperatingSystems: allOS, + }, + { + BaseExtEntity: boltz.BaseExtEntity{ + Id: "PROCESS", + ExtEntityFields: boltz.ExtEntityFields{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + Tags: map[string]interface{}{}, + Migrate: false, + }, + }, + Name: "Process Check", + OperatingSystems: []OperatingSystem{ + windows, + macOS, + linux, + }, + }, + { + BaseExtEntity: boltz.BaseExtEntity{ + Id: "DOMAIN", + ExtEntityFields: boltz.ExtEntityFields{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + Tags: map[string]interface{}{}, + Migrate: false, + }, + }, + Name: "Windows Domain Check", + OperatingSystems: []OperatingSystem{ + windows, + }, + }, + { + BaseExtEntity: boltz.BaseExtEntity{ + Id: "MAC", + ExtEntityFields: boltz.ExtEntityFields{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + Tags: map[string]interface{}{}, + Migrate: false, + }, + }, + Name: "MAC Address Check", + OperatingSystems: []OperatingSystem{ + windows, + linux, + macOS, + android, + }, + }, + } + + for _, postureCheckType := range types { + if err := m.stores.PostureCheckType.Create(step.Ctx, postureCheckType); err != nil { + step.SetError(err) + return + } + } + +} diff --git a/controller/persistence/migrations.go b/controller/persistence/migrations.go index 8fb8d8ce7..8418a8958 100644 --- a/controller/persistence/migrations.go +++ b/controller/persistence/migrations.go @@ -23,7 +23,7 @@ import ( ) const ( - CurrentDbVersion = 11 + CurrentDbVersion = 12 FieldVersion = "version" ) @@ -102,6 +102,10 @@ func (m *Migrations) migrate(step *boltz.MigrationStep) int { })) } + if step.CurrentVersion < 12 { + m.addPostureCheckTypes(step) + } + // current version if step.CurrentVersion <= CurrentDbVersion { return CurrentDbVersion diff --git a/controller/persistence/posture_check,_store.go b/controller/persistence/posture_check,_store.go index e28b433cf..9ccf91d01 100644 --- a/controller/persistence/posture_check,_store.go +++ b/controller/persistence/posture_check,_store.go @@ -17,6 +17,7 @@ package persistence import ( + "github.com/michaelquigley/pfxlog" "github.com/openziti/foundation/storage/ast" "github.com/openziti/foundation/storage/boltz" "go.etcd.io/bbolt" @@ -24,37 +25,73 @@ import ( const ( //Fields - FieldPostureCheckDescription = "description" + FieldPostureCheckTypeId = "typeId" + FieldPostureCheckVersion = "version" + FieldPostureCheckDescription = "description" ) +var postureCheckSubTypeMap = map[string]newPostureCheckSubType{ + "OS": newPostureCheckOperatingSystem, + "DOMAIN": newPostureCheckWindowsDomain, + "PROCESS": newPostureCheckProcess, + "MAC": newPostureCheckMacAddresses, +} + +type newPostureCheckSubType func() PostureCheckSubType + +type PostureCheckSubType interface { + LoadValues(store boltz.CrudStore, bucket *boltz.TypedBucket) + SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket) +} + +func newPostureCheck(typeId string) PostureCheckSubType { + if newChild, found := postureCheckSubTypeMap[typeId]; found { + return newChild() + } + return nil +} + type PostureCheck struct { boltz.BaseExtEntity - Name string - Fingerprint string - CertPem string - IsVerified bool - VerificationToken string - IsAutoPostureCheckEnrollmentEnabled bool - IsOttPostureCheckEnrollmentEnabled bool - IsAuthEnabled bool - IdentityRoles []string - IdentityNameFormat string + Name string + TypeId string + Description string + Version int64 + SubType PostureCheckSubType } func (entity *PostureCheck) GetName() string { return entity.Name } -func (entity *PostureCheck) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { +func (entity *PostureCheck) LoadValues(store boltz.CrudStore, bucket *boltz.TypedBucket) { entity.LoadBaseValues(bucket) entity.Name = bucket.GetStringOrError(FieldName) + entity.TypeId = bucket.GetStringOrError(FieldPostureCheckTypeId) + entity.Description = bucket.GetStringOrError(FieldPostureCheckDescription) + entity.Version = bucket.GetInt64WithDefault(FieldPostureCheckVersion, 0) + entity.SubType = newPostureCheck(entity.TypeId) + if entity.SubType == nil { + pfxlog.Logger().Panicf("cannot load unsupported posture check type [%v]", entity.TypeId) + } + childBucket := bucket.GetOrCreateBucket(entity.TypeId) + + entity.SubType.LoadValues(store, childBucket) } func (entity *PostureCheck) SetValues(ctx *boltz.PersistContext) { entity.SetBaseValues(ctx) ctx.SetString(FieldName, entity.Name) + ctx.SetString(FieldPostureCheckTypeId, entity.TypeId) + ctx.SetString(FieldPostureCheckDescription, entity.Description) + ctx.SetInt64(FieldPostureCheckVersion, entity.Version) + + childBucket := ctx.Bucket.GetOrCreateBucket(entity.TypeId) + + entity.SubType.SetValues(ctx, childBucket) + } func (entity *PostureCheck) GetEntityType() string { diff --git a/controller/persistence/posture_check_mac.go b/controller/persistence/posture_check_mac.go new file mode 100644 index 000000000..d83bd38fe --- /dev/null +++ b/controller/persistence/posture_check_mac.go @@ -0,0 +1,60 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" + "regexp" + "strings" +) + +const ( + FieldPostureCheckMacAddresses = "macAddresses" +) + +func newPostureCheckMacAddresses() PostureCheckSubType { + return &PostureCheckMacAddresses{ + MacAddresses: []string{}, + } +} + +type PostureCheckMacAddresses struct { + MacAddresses []string +} + +func (entity *PostureCheckMacAddresses) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { + for _, macAddress := range bucket.GetStringList(FieldPostureCheckMacAddresses) { + macAddress = cleanMacAddress(macAddress) + entity.MacAddresses = append(entity.MacAddresses, macAddress) + } +} + +func (entity *PostureCheckMacAddresses) SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket) { + var macAddresses []string + for _, macAddress := range entity.MacAddresses { + macAddress = cleanMacAddress(macAddress) + macAddresses = append(macAddresses, macAddress) + } + entity.MacAddresses = macAddresses + bucket.SetStringList(FieldPostureCheckMacAddresses, macAddresses, ctx.FieldChecker) +} + +func cleanMacAddress(macAddress string) string { + macAddress = strings.ToLower(macAddress) + nonHex := regexp.MustCompile("[^a-f0-9]") + return nonHex.ReplaceAllString(macAddress, "") +} diff --git a/controller/persistence/posture_check_os.go b/controller/persistence/posture_check_os.go new file mode 100644 index 000000000..582508349 --- /dev/null +++ b/controller/persistence/posture_check_os.go @@ -0,0 +1,80 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" +) + +const ( + FieldPostureCheckOsType = "osType" + FieldPostureCheckOsVersions = "osVersions" +) + +type PostureCheckOperatingSystem struct { + OperatingSystems []OperatingSystem +} + +type OperatingSystem struct { + OsType string + OsVersions []string +} + +func newPostureCheckOperatingSystem() PostureCheckSubType { + return &PostureCheckOperatingSystem{ + OperatingSystems: []OperatingSystem{}, + } +} + +func (entity *PostureCheckOperatingSystem) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { + + cursor := bucket.Cursor() + + for key, _ := cursor.First(); key != nil; key, _ = cursor.Next() { + osBucket := bucket.GetBucket(string(key)) + newOsMatch := OperatingSystem{ + OsType: osBucket.GetStringOrError(FieldPostureCheckOsType), + } + + for _, osVersion := range osBucket.GetStringList(FieldPostureCheckOsVersions) { + newOsMatch.OsVersions = append(newOsMatch.OsVersions, osVersion) + } + entity.OperatingSystems = append(entity.OperatingSystems, newOsMatch) + } + +} + +func (entity *PostureCheckOperatingSystem) SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket) { + osMap := map[string]OperatingSystem{} + + for _, os := range entity.OperatingSystems { + osMap[os.OsType] = os + } + + cursor := bucket.Cursor() + for key, _ := cursor.First(); key != nil; key, _ = cursor.Next() { + if _, found := osMap[string(key)]; !found { + _ = bucket.Delete(key) + } + } + + for _, os := range entity.OperatingSystems { + existing := bucket.GetOrCreateBucket(os.OsType) + existing.SetString(FieldPostureCheckOsType, os.OsType, ctx.FieldChecker) + existing.SetStringList(FieldPostureCheckOsVersions, os.OsVersions, ctx.FieldChecker) + } +} diff --git a/controller/persistence/posture_check_process.go b/controller/persistence/posture_check_process.go new file mode 100644 index 000000000..d7f92e2de --- /dev/null +++ b/controller/persistence/posture_check_process.go @@ -0,0 +1,58 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" +) + +const ( + FieldPostureCheckProcessOs = "os" + FieldPostureCheckProcessPath = "path" + FieldPostureCheckProcessHashes = "hashes" + FieldPostureCheckProcessFingerprint = "fingerprint" +) + +type PostureCheckProcess struct { + OperatingSystem string + Path string + Hashes []string + Fingerprint string +} + +func newPostureCheckProcess() PostureCheckSubType { + return &PostureCheckProcess{ + OperatingSystem: "", + Path: "", + Hashes: []string{}, + Fingerprint: "", + } +} + +func (entity *PostureCheckProcess) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { + entity.OperatingSystem = bucket.GetStringOrError(FieldPostureCheckProcessOs) + entity.Path = bucket.GetStringOrError(FieldPostureCheckProcessPath) + entity.Hashes = bucket.GetStringList(FieldPostureCheckProcessHashes) + entity.Fingerprint = bucket.GetStringOrError(FieldPostureCheckProcessFingerprint) +} + +func (entity *PostureCheckProcess) SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket) { + bucket.SetString(FieldPostureCheckProcessOs, entity.OperatingSystem, ctx.FieldChecker) + bucket.SetString(FieldPostureCheckProcessPath, entity.Path, ctx.FieldChecker) + bucket.SetStringList(FieldPostureCheckProcessHashes, entity.Hashes, ctx.FieldChecker) + bucket.SetString(FieldPostureCheckProcessFingerprint, entity.Fingerprint, ctx.FieldChecker) +} diff --git a/controller/persistence/posture_check_type_store.go b/controller/persistence/posture_check_type_store.go new file mode 100644 index 000000000..c55559cb9 --- /dev/null +++ b/controller/persistence/posture_check_type_store.go @@ -0,0 +1,151 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" + "go.etcd.io/bbolt" +) + +const ( + FieldPostureCheckTypeOperatingSystems = "operatingSystems" +) + +type PostureCheckType struct { + boltz.BaseExtEntity + Name string + OperatingSystems []OperatingSystem +} + +func (entity *PostureCheckType) GetName() string { + return entity.Name +} + +func (entity *PostureCheckType) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { + entity.LoadBaseValues(bucket) + entity.Name = bucket.GetStringOrError(FieldName) + + osBucket := bucket.GetOrCreateBucket(FieldPostureCheckTypeOperatingSystems) + cursor := osBucket.Cursor() + + for key, _ := cursor.First(); key != nil; key, _ = cursor.Next() { + curOs := osBucket.GetBucket(string(key)) + + if curOs == nil { + continue + } + + newOsMatch := OperatingSystem{ + OsType: curOs.GetStringOrError(FieldPostureCheckOsType), + } + + for _, osVersion := range curOs.GetStringList(FieldPostureCheckOsVersions) { + newOsMatch.OsVersions = append(newOsMatch.OsVersions, osVersion) + } + entity.OperatingSystems = append(entity.OperatingSystems, newOsMatch) + } +} + +func (entity *PostureCheckType) SetValues(ctx *boltz.PersistContext) { + entity.SetBaseValues(ctx) + ctx.SetString(FieldName, entity.Name) + + osMap := map[string]OperatingSystem{} + + for _, os := range entity.OperatingSystems { + osMap[os.OsType] = os + } + + osBucket := ctx.Bucket.GetOrCreateBucket(FieldPostureCheckTypeOperatingSystems) + cursor := osBucket.Cursor() + + for key, _ := cursor.First(); key != nil; key, _ = cursor.Next() { + if _, found := osMap[string(key)]; !found { + _ = osBucket.Delete(key) + } + } + + for _, os := range entity.OperatingSystems { + existing := osBucket.GetOrCreateBucket(os.OsType) + existing.SetString(FieldPostureCheckOsType, os.OsType, ctx.FieldChecker) + existing.SetStringList(FieldPostureCheckOsVersions, os.OsVersions, ctx.FieldChecker) + } +} + +func (entity *PostureCheckType) GetEntityType() string { + return EntityTypePostureCheckTypes +} + +type PostureCheckTypeStore interface { + NameIndexedStore + LoadOneById(tx *bbolt.Tx, id string) (*PostureCheckType, error) + LoadOneByName(tx *bbolt.Tx, id string) (*PostureCheckType, error) +} + +func newPostureCheckTypeStore(stores *stores) *postureCheckTypeStoreImpl { + store := &postureCheckTypeStoreImpl{ + baseStore: newBaseStore(stores, EntityTypePostureCheckTypes), + } + store.InitImpl(store) + return store +} + +type postureCheckTypeStoreImpl struct { + *baseStore + indexName boltz.ReadIndex +} + +func (store *postureCheckTypeStoreImpl) NewStoreEntity() boltz.Entity { + return &PostureCheckType{} +} + +func (store *postureCheckTypeStoreImpl) initializeLocal() { + store.AddExtEntitySymbols() + store.indexName = store.addUniqueNameField() +} + +func (store *postureCheckTypeStoreImpl) initializeLinked() { + // no links +} + +func (store *postureCheckTypeStoreImpl) GetNameIndex() boltz.ReadIndex { + return store.indexName +} + +func (store *postureCheckTypeStoreImpl) LoadOneById(tx *bbolt.Tx, id string) (*PostureCheckType, error) { + entity := &PostureCheckType{} + if err := store.baseLoadOneById(tx, id, entity); err != nil { + return nil, err + } + return entity, nil +} + +func (store *postureCheckTypeStoreImpl) LoadOneByName(tx *bbolt.Tx, name string) (*PostureCheckType, error) { + id := store.indexName.Read(tx, []byte(name)) + if id != nil { + return store.LoadOneById(tx, string(id)) + } + return nil, nil +} + +func (store *postureCheckTypeStoreImpl) LoadOneByQuery(tx *bbolt.Tx, query string) (*PostureCheckType, error) { + entity := &PostureCheckType{} + if found, err := store.BaseLoadOneByQuery(tx, query, entity); !found || err != nil { + return nil, err + } + return entity, nil +} diff --git a/controller/persistence/posture_check_windows_domain.go b/controller/persistence/posture_check_windows_domain.go new file mode 100644 index 000000000..dd37f3296 --- /dev/null +++ b/controller/persistence/posture_check_windows_domain.go @@ -0,0 +1,43 @@ +/* + Copyright NetFoundry, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package persistence + +import ( + "github.com/openziti/foundation/storage/boltz" +) + +const ( + FieldPostureCheckDomains = "domains" +) + +type PostureCheckWindowsDomains struct { + Domains []string +} + +func newPostureCheckWindowsDomain() PostureCheckSubType { + return &PostureCheckWindowsDomains{ + Domains: []string{}, + } +} + +func (entity *PostureCheckWindowsDomains) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBucket) { + entity.Domains = bucket.GetStringList(FieldPostureCheckDomains) +} + +func (entity *PostureCheckWindowsDomains) SetValues(ctx *boltz.PersistContext, bucket *boltz.TypedBucket) { + bucket.SetStringList(FieldPostureCheckDomains, entity.Domains, ctx.FieldChecker) +} diff --git a/controller/persistence/stores.go b/controller/persistence/stores.go index 01bcb78bc..8e2e4e434 100644 --- a/controller/persistence/stores.go +++ b/controller/persistence/stores.go @@ -54,6 +54,7 @@ type Stores struct { Enrollment EnrollmentStore Authenticator AuthenticatorStore PostureCheck PostureCheckStore + PostureCheckType PostureCheckTypeStore storeMap map[reflect.Type]boltz.CrudStore } @@ -139,6 +140,7 @@ type stores struct { enrollment *enrollmentStoreImpl authenticator *authenticatorStoreImpl postureCheck *postureCheckStoreImpl + postureCheckType *postureCheckTypeStoreImpl } func NewBoltStores(dbProvider DbProvider) (*Stores, error) { @@ -170,6 +172,7 @@ func NewBoltStores(dbProvider DbProvider) (*Stores, error) { internalStores.servicePolicy = newServicePolicyStore(internalStores) internalStores.session = newSessionStore(internalStores) internalStores.postureCheck = newPostureCheckStore(internalStores) + internalStores.postureCheckType = newPostureCheckTypeStore(internalStores) externalStores := &Stores{ DbProvider: dbProvider, @@ -196,6 +199,7 @@ func NewBoltStores(dbProvider DbProvider) (*Stores, error) { Authenticator: internalStores.authenticator, Enrollment: internalStores.enrollment, PostureCheck: internalStores.postureCheck, + PostureCheckType: internalStores.postureCheckType, storeMap: make(map[reflect.Type]boltz.CrudStore), } From 01f4d4adfe32670052d84bcc9df2b4d6e8a7db79 Mon Sep 17 00:00:00 2001 From: Andrew Martinez Date: Tue, 13 Oct 2020 15:20:55 -0400 Subject: [PATCH 2/3] spelling fixes --- controller/model/posture_check_model_mac.go | 2 +- controller/model/posture_check_model_os.go | 2 +- controller/model/posture_check_model_process.go | 2 +- controller/model/posture_check_model_windows_domain.go | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/controller/model/posture_check_model_mac.go b/controller/model/posture_check_model_mac.go index 2973109dc..b8998e422 100644 --- a/controller/model/posture_check_model_mac.go +++ b/controller/model/posture_check_model_mac.go @@ -34,7 +34,7 @@ func (p *PostureCheckMacAddresses) fillFrom(handler Handler, tx *bbolt.Tx, check subCheck := subType.(*persistence.PostureCheckMacAddresses) if subCheck == nil { - return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + return fmt.Errorf("could not covert mac address check to bolt type") } p.MacAddresses = subCheck.MacAddresses diff --git a/controller/model/posture_check_model_os.go b/controller/model/posture_check_model_os.go index a84cb6d6b..258d6131c 100644 --- a/controller/model/posture_check_model_os.go +++ b/controller/model/posture_check_model_os.go @@ -39,7 +39,7 @@ func (p *PostureCheckOperatingSystem) fillFrom(handler Handler, tx *bbolt.Tx, ch subCheck := subType.(*persistence.PostureCheckOperatingSystem) if subCheck == nil { - return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + return fmt.Errorf("could not covert os check to bolt type") } for _, osMatch := range subCheck.OperatingSystems { diff --git a/controller/model/posture_check_model_process.go b/controller/model/posture_check_model_process.go index 6108d4ad9..3d2a3f189 100644 --- a/controller/model/posture_check_model_process.go +++ b/controller/model/posture_check_model_process.go @@ -37,7 +37,7 @@ func (p *PostureCheckProcess) fillFrom(handler Handler, tx *bbolt.Tx, check *per subCheck := subType.(*persistence.PostureCheckProcess) if subCheck == nil { - return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + return fmt.Errorf("could not covert process check to bolt type") } p.OperatingSystem = subCheck.OperatingSystem diff --git a/controller/model/posture_check_model_windows_domain.go b/controller/model/posture_check_model_windows_domain.go index 21fd43c0e..aed74c10f 100644 --- a/controller/model/posture_check_model_windows_domain.go +++ b/controller/model/posture_check_model_windows_domain.go @@ -34,7 +34,7 @@ func (p *PostureCheckWindowsDomains) fillFrom(handler Handler, tx *bbolt.Tx, che subCheck := subType.(*persistence.PostureCheckWindowsDomains) if subCheck == nil { - return fmt.Errorf("could not covert mac address check to bolt mac address cheeck") + return fmt.Errorf("could not covert domain check to bolt type") } p.Domains = subCheck.Domains From 568eb129c7cc20bff3a69cc10d1d3e701e5d77c0 Mon Sep 17 00:00:00 2001 From: Andrew Martinez Date: Tue, 13 Oct 2020 17:03:26 -0400 Subject: [PATCH 3/3] address PR comments - remove unused property: type - add service policy plumbing for postureCheck roles - add denomralization for posture check roles - make encryptionRequired flag reqquired --- .../routes/posture_check_api_model.go | 42 +++++++++-- .../internal/routes/service_api_model.go | 2 +- .../routes/service_policy_api_model.go | 51 +++++++------- controller/model/posture_check_model.go | 23 ++++--- .../model/posture_check_type_handlers.go | 27 -------- controller/model/posture_check_type_model.go | 2 +- controller/model/service_policy_model.go | 25 ++++--- controller/persistence/base_entity.go | 7 +- .../persistence/posture_check,_store.go | 51 ++++++++++++-- .../persistence/service_policy_store.go | 48 +++++++++++-- rest_model/posture_check_create.go | 36 ++++++++++ rest_model/posture_check_detail.go | 55 ++++++++------- rest_model/posture_check_domain_create.go | 40 +++++++++++ rest_model/posture_check_domain_detail.go | 69 ++++++++++--------- rest_model/posture_check_domain_patch.go | 40 +++++++++++ rest_model/posture_check_domain_update.go | 40 +++++++++++ .../posture_check_mac_address_create.go | 40 +++++++++++ .../posture_check_mac_address_detail.go | 69 ++++++++++--------- rest_model/posture_check_mac_address_patch.go | 40 +++++++++++ .../posture_check_mac_address_update.go | 40 +++++++++++ .../posture_check_operating_system_create.go | 40 +++++++++++ .../posture_check_operating_system_detail.go | 69 ++++++++++--------- .../posture_check_operating_system_patch.go | 40 +++++++++++ .../posture_check_operating_system_update.go | 40 +++++++++++ rest_model/posture_check_patch.go | 36 ++++++++++ rest_model/posture_check_process_create.go | 40 +++++++++++ rest_model/posture_check_process_detail.go | 69 ++++++++++--------- rest_model/posture_check_process_patch.go | 40 +++++++++++ rest_model/posture_check_process_update.go | 40 +++++++++++ rest_model/posture_check_update.go | 36 ++++++++++ rest_model/service_create.go | 16 ++++- rest_server/embedded_spec.go | 40 ++++++++--- specs/swagger.yml | 13 +++- tests/context.go | 1 + tests/entities.go | 2 + 35 files changed, 1013 insertions(+), 256 deletions(-) diff --git a/controller/internal/routes/posture_check_api_model.go b/controller/internal/routes/posture_check_api_model.go index dc81c25d3..ac055b2a4 100644 --- a/controller/internal/routes/posture_check_api_model.go +++ b/controller/internal/routes/posture_check_api_model.go @@ -26,6 +26,7 @@ import ( "github.com/openziti/edge/rest_model" "github.com/openziti/fabric/controller/models" "github.com/openziti/foundation/util/stringz" + "strings" ) const EntityNamePostureCheck = "posture-checks" @@ -52,10 +53,11 @@ func MapCreatePostureCheckToModel(postureCheck rest_model.PostureCheckCreate) *m BaseEntity: models.BaseEntity{ Tags: postureCheck.Tags(), }, - Name: stringz.OrEmpty(postureCheck.Name()), - TypeId: string(postureCheck.TypeID()), - Description: stringz.OrEmpty(postureCheck.Description()), - Version: 1, + Name: stringz.OrEmpty(postureCheck.Name()), + TypeId: string(postureCheck.TypeID()), + Description: stringz.OrEmpty(postureCheck.Description()), + Version: 1, + RoleAttributes: postureCheck.RoleAttributes(), } switch apiSubType := postureCheck.(type) { @@ -98,7 +100,8 @@ func MapUpdatePostureCheckToModel(id string, postureCheck rest_model.PostureChec Tags: postureCheck.Tags(), Id: id, }, - Name: stringz.OrEmpty(postureCheck.Name()), + Name: stringz.OrEmpty(postureCheck.Name()), + RoleAttributes: postureCheck.RoleAttributes(), } return ret @@ -110,7 +113,8 @@ func MapPatchPostureCheckToModel(id string, postureCheck rest_model.PostureCheck Tags: postureCheck.Tags(), Id: id, }, - Name: postureCheck.Name(), + Name: postureCheck.Name(), + RoleAttributes: postureCheck.RoleAttributes(), } return ret @@ -197,4 +201,30 @@ func setBaseEntityDetailsOnPostureCheck(check rest_model.PostureCheckDetail, i * check.SetName(&i.Name) check.SetTypeID(i.TypeId) check.SetVersion(&i.Version) + check.SetRoleAttributes(i.RoleAttributes) +} + +func GetNamedPostureCheckRoles(postureCheckHandler *model.PostureCheckHandler, roles []string) rest_model.NamedRoles { + result := rest_model.NamedRoles{} + for _, role := range roles { + if strings.HasPrefix(role, "@") { + + postureCheck, err := postureCheckHandler.Read(role[1:]) + if err != nil { + pfxlog.Logger().Errorf("error converting posture check role [%s] to a named role: %v", role, err) + continue + } + + result = append(result, &rest_model.NamedRole{ + Role: role, + Name: "@" + postureCheck.Name, + }) + } else { + result = append(result, &rest_model.NamedRole{ + Role: role, + Name: role, + }) + } + } + return result } diff --git a/controller/internal/routes/service_api_model.go b/controller/internal/routes/service_api_model.go index 2e25b9ab6..3d8dab9bd 100644 --- a/controller/internal/routes/service_api_model.go +++ b/controller/internal/routes/service_api_model.go @@ -61,7 +61,7 @@ func MapCreateServiceToModel(service *rest_model.ServiceCreate) *model.Service { TerminatorStrategy: service.TerminatorStrategy, RoleAttributes: service.RoleAttributes, Configs: service.Configs, - EncryptionRequired: service.EncryptionRequired, + EncryptionRequired: *service.EncryptionRequired, } return ret diff --git a/controller/internal/routes/service_policy_api_model.go b/controller/internal/routes/service_policy_api_model.go index 22de16c50..3994f9240 100644 --- a/controller/internal/routes/service_policy_api_model.go +++ b/controller/internal/routes/service_policy_api_model.go @@ -54,11 +54,12 @@ func MapCreateServicePolicyToModel(policy *rest_model.ServicePolicyCreate) *mode BaseEntity: models.BaseEntity{ Tags: policy.Tags, }, - Name: stringz.OrEmpty(policy.Name), - PolicyType: string(policy.Type), - Semantic: string(policy.Semantic), - ServiceRoles: policy.ServiceRoles, - IdentityRoles: policy.IdentityRoles, + Name: stringz.OrEmpty(policy.Name), + PolicyType: string(policy.Type), + Semantic: string(policy.Semantic), + ServiceRoles: policy.ServiceRoles, + IdentityRoles: policy.IdentityRoles, + PostureCheckRoles: policy.PostureCheckRoles, } return ret @@ -70,11 +71,12 @@ func MapUpdateServicePolicyToModel(id string, policy *rest_model.ServicePolicyUp Tags: policy.Tags, Id: id, }, - Name: stringz.OrEmpty(policy.Name), - PolicyType: string(policy.Type), - Semantic: string(policy.Semantic), - ServiceRoles: policy.ServiceRoles, - IdentityRoles: policy.IdentityRoles, + Name: stringz.OrEmpty(policy.Name), + PolicyType: string(policy.Type), + Semantic: string(policy.Semantic), + ServiceRoles: policy.ServiceRoles, + IdentityRoles: policy.IdentityRoles, + PostureCheckRoles: policy.PostureCheckRoles, } return ret @@ -86,11 +88,12 @@ func MapPatchServicePolicyToModel(id string, policy *rest_model.ServicePolicyPat Tags: policy.Tags, Id: id, }, - Name: policy.Name, - PolicyType: string(policy.Type), - Semantic: string(policy.Semantic), - ServiceRoles: policy.ServiceRoles, - IdentityRoles: policy.IdentityRoles, + Name: policy.Name, + PolicyType: string(policy.Type), + Semantic: string(policy.Semantic), + ServiceRoles: policy.ServiceRoles, + IdentityRoles: policy.IdentityRoles, + PostureCheckRoles: policy.PostureCheckRoles, } return ret @@ -119,14 +122,16 @@ func MapServicePolicyToRestEntity(ae *env.AppEnv, _ *response.RequestContext, e func MapServicePolicyToRestModel(ae *env.AppEnv, policy *model.ServicePolicy) (*rest_model.ServicePolicyDetail, error) { ret := &rest_model.ServicePolicyDetail{ - BaseEntity: BaseEntityToRestModel(policy, ServicePolicyLinkFactory), - IdentityRoles: policy.IdentityRoles, - IdentityRolesDisplay: GetNamedIdentityRoles(ae.GetHandlers().Identity, policy.IdentityRoles), - Name: &policy.Name, - Semantic: rest_model.Semantic(policy.Semantic), - ServiceRoles: policy.ServiceRoles, - ServiceRolesDisplay: GetNamedServiceRoles(ae.GetHandlers().EdgeService, policy.ServiceRoles), - Type: rest_model.DialBind(policy.PolicyType), + BaseEntity: BaseEntityToRestModel(policy, ServicePolicyLinkFactory), + IdentityRoles: policy.IdentityRoles, + IdentityRolesDisplay: GetNamedIdentityRoles(ae.GetHandlers().Identity, policy.IdentityRoles), + Name: &policy.Name, + Semantic: rest_model.Semantic(policy.Semantic), + ServiceRoles: policy.ServiceRoles, + ServiceRolesDisplay: GetNamedServiceRoles(ae.GetHandlers().EdgeService, policy.ServiceRoles), + Type: rest_model.DialBind(policy.PolicyType), + PostureCheckRoles: policy.PostureCheckRoles, + PostureCheckRolesDisplay: GetNamedPostureCheckRoles(ae.GetHandlers().PostureCheck, policy.PostureCheckRoles), } return ret, nil diff --git a/controller/model/posture_check_model.go b/controller/model/posture_check_model.go index 58bac4f99..0e464db37 100644 --- a/controller/model/posture_check_model.go +++ b/controller/model/posture_check_model.go @@ -28,11 +28,12 @@ import ( type PostureCheck struct { models.BaseEntity - Name string - TypeId string - Description string - Version int64 - SubType PostureCheckSubType + Name string + TypeId string + Description string + Version int64 + RoleAttributes []string + SubType PostureCheckSubType } type PostureCheckSubType interface { @@ -68,6 +69,7 @@ func (entity *PostureCheck) fillFrom(handler Handler, tx *bbolt.Tx, boltEntity b entity.TypeId = boltPostureCheck.TypeId entity.Description = boltPostureCheck.Description entity.Version = boltPostureCheck.Version + entity.RoleAttributes = boltPostureCheck.RoleAttributes subType := newSubType(entity.TypeId) @@ -86,11 +88,12 @@ func (entity *PostureCheck) fillFrom(handler Handler, tx *bbolt.Tx, boltEntity b func (entity *PostureCheck) toBoltEntityForCreate(tx *bbolt.Tx, handler Handler) (boltz.Entity, error) { boltEntity := &persistence.PostureCheck{ - BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), - Name: entity.Name, - TypeId: entity.TypeId, - Description: entity.Description, - Version: 1, + BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), + Name: entity.Name, + TypeId: entity.TypeId, + Description: entity.Description, + Version: 1, + RoleAttributes: entity.RoleAttributes, } var err error diff --git a/controller/model/posture_check_type_handlers.go b/controller/model/posture_check_type_handlers.go index ed916c289..e7d2a886c 100644 --- a/controller/model/posture_check_type_handlers.go +++ b/controller/model/posture_check_type_handlers.go @@ -16,10 +16,6 @@ package model -import ( - "github.com/openziti/foundation/storage/boltz" -) - func NewPostureCheckTypeHandler(env Env) *PostureCheckTypeHandler { handler := &PostureCheckTypeHandler{ baseHandler: newBaseHandler(env, env.GetStores().PostureCheckType), @@ -48,29 +44,6 @@ func (handler *PostureCheckTypeHandler) Read(id string) (*PostureCheckType, erro return modelEntity, nil } -func (handler *PostureCheckTypeHandler) ReadByIdOrName(idOrName string) (*PostureCheckType, error) { - modelEntity := &PostureCheckType{} - err := handler.readEntity(idOrName, modelEntity) - - if err == nil { - return modelEntity, nil - } - - if !boltz.IsErrNotFoundErr(err) { - return nil, err - } - - if modelEntity.Id == "" { - modelEntity, err = handler.ReadByName(idOrName) - } - - if err != nil { - return nil, err - } - - return modelEntity, nil -} - func (handler *PostureCheckTypeHandler) Delete(id string) error { return handler.deleteEntity(id) } diff --git a/controller/model/posture_check_type_model.go b/controller/model/posture_check_type_model.go index 0f32eb5e2..dbb25ce0d 100644 --- a/controller/model/posture_check_type_model.go +++ b/controller/model/posture_check_type_model.go @@ -27,7 +27,7 @@ import ( type PostureCheckType struct { models.BaseEntity - Name string `json:"name"` + Name string OperatingSystems []OperatingSystem } diff --git a/controller/model/service_policy_model.go b/controller/model/service_policy_model.go index 10fe51b1f..f5cb87fc2 100644 --- a/controller/model/service_policy_model.go +++ b/controller/model/service_policy_model.go @@ -30,11 +30,12 @@ import ( type ServicePolicy struct { models.BaseEntity - Name string - PolicyType string - Semantic string - IdentityRoles []string - ServiceRoles []string + Name string + PolicyType string + Semantic string + IdentityRoles []string + ServiceRoles []string + PostureCheckRoles []string } func (entity *ServicePolicy) validatePolicyType() error { @@ -54,12 +55,13 @@ func (entity *ServicePolicy) toBoltEntity() (boltz.Entity, error) { } return &persistence.ServicePolicy{ - BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), - Name: entity.Name, - PolicyType: policyType, - Semantic: entity.Semantic, - IdentityRoles: entity.IdentityRoles, - ServiceRoles: entity.ServiceRoles, + BaseExtEntity: *boltz.NewExtEntity(entity.Id, entity.Tags), + Name: entity.Name, + PolicyType: policyType, + Semantic: entity.Semantic, + IdentityRoles: entity.IdentityRoles, + ServiceRoles: entity.ServiceRoles, + PostureCheckRoles: entity.PostureCheckRoles, }, nil } @@ -94,5 +96,6 @@ func (entity *ServicePolicy) fillFrom(_ Handler, _ *bbolt.Tx, boltEntity boltz.E entity.Semantic = boltServicePolicy.Semantic entity.ServiceRoles = boltServicePolicy.ServiceRoles entity.IdentityRoles = boltServicePolicy.IdentityRoles + entity.PostureCheckRoles = boltServicePolicy.PostureCheckRoles return nil } diff --git a/controller/persistence/base_entity.go b/controller/persistence/base_entity.go index 147e7ca8d..17664e833 100644 --- a/controller/persistence/base_entity.go +++ b/controller/persistence/base_entity.go @@ -45,9 +45,10 @@ const ( FieldSemantic = "semantic" FieldRoleAttributes = "roleAttributes" - FieldEdgeRouterRoles = "edgeRouterRoles" - FieldIdentityRoles = "identityRoles" - FieldServiceRoles = "serviceRoles" + FieldEdgeRouterRoles = "edgeRouterRoles" + FieldIdentityRoles = "identityRoles" + FieldServiceRoles = "serviceRoles" + FieldPostureCheckRoles = "postureCheckRoles" SemanticAllOf = "AllOf" SemanticAnyOf = "AnyOf" diff --git a/controller/persistence/posture_check,_store.go b/controller/persistence/posture_check,_store.go index 9ccf91d01..4a1b4a794 100644 --- a/controller/persistence/posture_check,_store.go +++ b/controller/persistence/posture_check,_store.go @@ -20,6 +20,7 @@ import ( "github.com/michaelquigley/pfxlog" "github.com/openziti/foundation/storage/ast" "github.com/openziti/foundation/storage/boltz" + "github.com/openziti/foundation/util/errorz" "go.etcd.io/bbolt" ) @@ -53,11 +54,12 @@ func newPostureCheck(typeId string) PostureCheckSubType { type PostureCheck struct { boltz.BaseExtEntity - Name string - TypeId string - Description string - Version int64 - SubType PostureCheckSubType + Name string + TypeId string + Description string + Version int64 + RoleAttributes []string + SubType PostureCheckSubType } func (entity *PostureCheck) GetName() string { @@ -70,6 +72,7 @@ func (entity *PostureCheck) LoadValues(store boltz.CrudStore, bucket *boltz.Type entity.TypeId = bucket.GetStringOrError(FieldPostureCheckTypeId) entity.Description = bucket.GetStringOrError(FieldPostureCheckDescription) entity.Version = bucket.GetInt64WithDefault(FieldPostureCheckVersion, 0) + entity.RoleAttributes = bucket.GetStringList(FieldRoleAttributes) entity.SubType = newPostureCheck(entity.TypeId) if entity.SubType == nil { @@ -87,11 +90,17 @@ func (entity *PostureCheck) SetValues(ctx *boltz.PersistContext) { ctx.SetString(FieldPostureCheckTypeId, entity.TypeId) ctx.SetString(FieldPostureCheckDescription, entity.Description) ctx.SetInt64(FieldPostureCheckVersion, entity.Version) + ctx.SetStringList(FieldRoleAttributes, entity.RoleAttributes) childBucket := ctx.Bucket.GetOrCreateBucket(entity.TypeId) entity.SubType.SetValues(ctx, childBucket) + // index change won't fire if we don't have any roles on create, but we need to evaluate if we match any #all roles + store := ctx.Store.(*postureCheckStoreImpl) + if ctx.IsCreate && len(entity.RoleAttributes) == 0 { + store.rolesChanged(ctx.Bucket.Tx(), []byte(entity.Id), nil, nil, ctx.Bucket) + } } func (entity *PostureCheck) GetEntityType() string { @@ -103,6 +112,7 @@ type PostureCheckStore interface { LoadOneById(tx *bbolt.Tx, id string) (*PostureCheck, error) LoadOneByName(tx *bbolt.Tx, id string) (*PostureCheck, error) LoadOneByQuery(tx *bbolt.Tx, query string) (*PostureCheck, error) + GetRoleAttributesIndex() boltz.SetReadIndex } func newPostureCheckStore(stores *stores) *postureCheckStoreImpl { @@ -116,19 +126,39 @@ func newPostureCheckStore(stores *stores) *postureCheckStoreImpl { type postureCheckStoreImpl struct { *baseStore indexName boltz.ReadIndex + + symbolServicePolicies boltz.EntitySymbol + symbolRoleAttributes boltz.EntitySetSymbol + indexRoleAttributes boltz.SetReadIndex } func (store *postureCheckStoreImpl) NewStoreEntity() boltz.Entity { return &PostureCheck{} } +func (store *postureCheckStoreImpl) GetRoleAttributesIndex() boltz.SetReadIndex { + return store.indexRoleAttributes +} + func (store *postureCheckStoreImpl) initializeLocal() { store.AddExtEntitySymbols() store.indexName = store.addUniqueNameField() store.AddSymbol(FieldPostureCheckDescription, ast.NodeTypeString) + + store.symbolRoleAttributes = store.AddSetSymbol(FieldRoleAttributes, ast.NodeTypeString) + store.indexRoleAttributes = store.AddSetIndex(store.symbolRoleAttributes) + + store.symbolServicePolicies = store.AddFkSetSymbol(EntityTypeServicePolicies, store.stores.servicePolicy) + + store.indexRoleAttributes.AddListener(store.rolesChanged) } func (store *postureCheckStoreImpl) initializeLinked() { + store.AddLinkCollection(store.symbolServicePolicies, store.stores.servicePolicy.symbolPostureChecks) +} + +func (store *postureCheckStoreImpl) GetNameIndex() boltz.ReadIndex { + return store.indexName } func (store *postureCheckStoreImpl) LoadOneById(tx *bbolt.Tx, id string) (*PostureCheck, error) { @@ -162,3 +192,14 @@ func (store *postureCheckStoreImpl) DeleteById(ctx boltz.MutateContext, id strin func (store *postureCheckStoreImpl) Update(ctx boltz.MutateContext, entity boltz.Entity, checker boltz.FieldChecker) error { return store.baseStore.Update(ctx, entity, checker) } + +func (store *postureCheckStoreImpl) rolesChanged(tx *bbolt.Tx, rowId []byte, _ []boltz.FieldTypeAndValue, new []boltz.FieldTypeAndValue, holder errorz.ErrorHolder) { + ctx := &roleAttributeChangeContext{ + tx: tx, + rolesSymbol: store.stores.servicePolicy.symbolPostureChecks, + linkCollection: store.stores.servicePolicy.postureCheckCollection, + relatedLinkCollection: store.stores.servicePolicy.serviceCollection, + ErrorHolder: holder, + } + store.updateServicePolicyRelatedRoles(ctx, rowId, new) +} diff --git a/controller/persistence/service_policy_store.go b/controller/persistence/service_policy_store.go index d7aa0d546..f921edbe5 100644 --- a/controller/persistence/service_policy_store.go +++ b/controller/persistence/service_policy_store.go @@ -39,11 +39,12 @@ func newServicePolicy(name string) *ServicePolicy { type ServicePolicy struct { boltz.BaseExtEntity - PolicyType int32 - Name string - Semantic string - IdentityRoles []string - ServiceRoles []string + PolicyType int32 + Name string + Semantic string + IdentityRoles []string + ServiceRoles []string + PostureCheckRoles []string } func (entity *ServicePolicy) GetName() string { @@ -61,6 +62,7 @@ func (entity *ServicePolicy) LoadValues(_ boltz.CrudStore, bucket *boltz.TypedBu entity.Semantic = bucket.GetStringWithDefault(FieldSemantic, SemanticAllOf) entity.IdentityRoles = bucket.GetStringList(FieldIdentityRoles) entity.ServiceRoles = bucket.GetStringList(FieldServiceRoles) + entity.PostureCheckRoles = bucket.GetStringList(FieldPostureCheckRoles) } func (entity *ServicePolicy) SetValues(ctx *boltz.PersistContext) { @@ -81,6 +83,10 @@ func (entity *ServicePolicy) SetValues(ctx *boltz.PersistContext) { ctx.Bucket.SetError(err) } + if err := validateRolesAndIds(FieldPostureCheckRoles, entity.PostureCheckRoles); err != nil { + ctx.Bucket.SetError(err) + } + if ctx.ProceedWithSet(FieldSemantic) && !isSemanticValid(entity.Semantic) { ctx.Bucket.SetError(validation.NewFieldError("invalid semantic", FieldSemantic, entity.Semantic)) return @@ -99,10 +105,16 @@ func (entity *ServicePolicy) SetValues(ctx *boltz.PersistContext) { if valueSet && !stringz.EqualSlices(oldIdentityRoles, entity.IdentityRoles) { servicePolicyStore.identityRolesUpdated(ctx, entity) } + oldServiceRoles, valueSet := ctx.GetAndSetStringList(FieldServiceRoles, entity.ServiceRoles) if valueSet && !stringz.EqualSlices(oldServiceRoles, entity.ServiceRoles) { servicePolicyStore.serviceRolesUpdated(ctx, entity) } + + oldPostureCheckRoles, valueSet := ctx.GetAndSetStringList(FieldPostureCheckRoles, entity.PostureCheckRoles) + if valueSet && !stringz.EqualSlices(oldPostureCheckRoles, entity.PostureCheckRoles) { + servicePolicyStore.postureCheckRolesUpdated(ctx, entity) + } } func (entity *ServicePolicy) GetEntityType() string { @@ -147,9 +159,11 @@ type servicePolicyStoreImpl struct { symbolServiceRoles boltz.EntitySetSymbol symbolIdentities boltz.EntitySetSymbol symbolServices boltz.EntitySetSymbol + symbolPostureChecks boltz.EntitySetSymbol - identityCollection boltz.LinkCollection - serviceCollection boltz.LinkCollection + identityCollection boltz.LinkCollection + serviceCollection boltz.LinkCollection + postureCheckCollection boltz.LinkCollection } func (store *servicePolicyStoreImpl) GetNameIndex() boltz.ReadIndex { @@ -170,11 +184,13 @@ func (store *servicePolicyStoreImpl) initializeLocal() { store.symbolServiceRoles = store.AddSetSymbol(FieldServiceRoles, ast.NodeTypeString) store.symbolIdentities = store.AddFkSetSymbol(EntityTypeIdentities, store.stores.identity) store.symbolServices = store.AddFkSetSymbol(db.EntityTypeServices, store.stores.edgeService) + store.symbolPostureChecks = store.AddFkSetSymbol(EntityTypePostureChecks, store.stores.postureCheck) } func (store *servicePolicyStoreImpl) initializeLinked() { store.serviceCollection = store.AddLinkCollection(store.symbolServices, store.stores.edgeService.symbolServicePolicies) store.identityCollection = store.AddLinkCollection(store.symbolIdentities, store.stores.identity.symbolServicePolicies) + store.postureCheckCollection = store.AddLinkCollection(store.symbolPostureChecks, store.stores.postureCheck.symbolServicePolicies) } func (store *servicePolicyStoreImpl) LoadOneById(tx *bbolt.Tx, id string) (*ServicePolicy, error) { @@ -234,6 +250,24 @@ func (store *servicePolicyStoreImpl) identityRolesUpdated(persistCtx *boltz.Pers EvaluatePolicy(ctx, policy, store.stores.identity.symbolRoleAttributes) } +func (store *servicePolicyStoreImpl) postureCheckRolesUpdated(persistCtx *boltz.PersistContext, policy *ServicePolicy) { + ctx := &roleAttributeChangeContext{ + tx: persistCtx.Bucket.Tx(), + rolesSymbol: store.symbolPostureChecks, + linkCollection: store.postureCheckCollection, + relatedLinkCollection: store.serviceCollection, + ErrorHolder: persistCtx.Bucket, + } + + if policy.PolicyType == PolicyTypeDial { + ctx.denormLinkCollection = store.stores.identity.dialServicesCollection + } else { + ctx.denormLinkCollection = store.stores.identity.bindServicesCollection + } + + EvaluatePolicy(ctx, policy, store.stores.postureCheck.symbolRoleAttributes) +} + func (store *servicePolicyStoreImpl) DeleteById(ctx boltz.MutateContext, id string) error { policy, err := store.LoadOneById(ctx.Tx(), id) if err != nil { diff --git a/rest_model/posture_check_create.go b/rest_model/posture_check_create.go index 37a5d00fc..bbe02a4bf 100644 --- a/rest_model/posture_check_create.go +++ b/rest_model/posture_check_create.go @@ -58,6 +58,10 @@ type PostureCheckCreate interface { Name() *string SetName(*string) + // role attributes + RoleAttributes() Attributes + SetRoleAttributes(Attributes) + // tags Tags() Tags SetTags(Tags) @@ -76,6 +80,8 @@ type postureCheckCreate struct { nameField *string + roleAttributesField Attributes + tagsField Tags typeIdField PostureCheckType @@ -101,6 +107,16 @@ func (m *postureCheckCreate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this polymorphic type +func (m *postureCheckCreate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this polymorphic type +func (m *postureCheckCreate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this polymorphic type func (m *postureCheckCreate) Tags() Tags { return m.tagsField @@ -212,6 +228,10 @@ func (m *postureCheckCreate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -240,6 +260,22 @@ func (m *postureCheckCreate) validateName(formats strfmt.Registry) error { return nil } +func (m *postureCheckCreate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *postureCheckCreate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_detail.go b/rest_model/posture_check_detail.go index 9f5068b92..91752ee1d 100644 --- a/rest_model/posture_check_detail.go +++ b/rest_model/posture_check_detail.go @@ -73,16 +73,16 @@ type PostureCheckDetail interface { Name() *string SetName(*string) + // role attributes + // Required: true + RoleAttributes() Attributes + SetRoleAttributes(Attributes) + // tags // Required: true Tags() Tags SetTags(Tags) - // type - // Required: true - Type() *string - SetType(*string) - // type Id // Required: true TypeID() string @@ -114,9 +114,9 @@ type postureCheckDetail struct { nameField *string - tagsField Tags + roleAttributesField Attributes - typeField *string + tagsField Tags typeIdField string @@ -175,6 +175,16 @@ func (m *postureCheckDetail) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this polymorphic type +func (m *postureCheckDetail) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this polymorphic type +func (m *postureCheckDetail) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this polymorphic type func (m *postureCheckDetail) Tags() Tags { return m.tagsField @@ -185,16 +195,6 @@ func (m *postureCheckDetail) SetTags(val Tags) { m.tagsField = val } -// Type gets the type of this polymorphic type -func (m *postureCheckDetail) Type() *string { - return m.typeField -} - -// SetType sets the type of this polymorphic type -func (m *postureCheckDetail) SetType(val *string) { - m.typeField = val -} - // TypeID gets the type Id of this polymorphic type func (m *postureCheckDetail) TypeID() string { return "PostureCheckDetail" @@ -328,11 +328,11 @@ func (m *postureCheckDetail) Validate(formats strfmt.Registry) error { res = append(res, err) } - if err := m.validateTags(formats); err != nil { + if err := m.validateRoleAttributes(formats); err != nil { res = append(res, err) } - if err := m.validateType(formats); err != nil { + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -402,11 +402,15 @@ func (m *postureCheckDetail) validateName(formats strfmt.Registry) error { return nil } -func (m *postureCheckDetail) validateTags(formats strfmt.Registry) error { +func (m *postureCheckDetail) validateRoleAttributes(formats strfmt.Registry) error { - if err := m.Tags().Validate(formats); err != nil { + if err := validate.Required("roleAttributes", "body", m.RoleAttributes()); err != nil { + return err + } + + if err := m.RoleAttributes().Validate(formats); err != nil { if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("tags") + return ve.ValidateName("roleAttributes") } return err } @@ -414,9 +418,12 @@ func (m *postureCheckDetail) validateTags(formats strfmt.Registry) error { return nil } -func (m *postureCheckDetail) validateType(formats strfmt.Registry) error { +func (m *postureCheckDetail) validateTags(formats strfmt.Registry) error { - if err := validate.Required("type", "body", m.Type()); err != nil { + if err := m.Tags().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("tags") + } return err } diff --git a/rest_model/posture_check_domain_create.go b/rest_model/posture_check_domain_create.go index 5319b778a..77f3261fd 100644 --- a/rest_model/posture_check_domain_create.go +++ b/rest_model/posture_check_domain_create.go @@ -47,6 +47,8 @@ type PostureCheckDomainCreate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // domains @@ -75,6 +77,16 @@ func (m *PostureCheckDomainCreate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckDomainCreate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckDomainCreate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckDomainCreate) Tags() Tags { return m.tagsField @@ -118,6 +130,8 @@ func (m *PostureCheckDomainCreate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -136,6 +150,8 @@ func (m *PostureCheckDomainCreate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -172,6 +188,8 @@ func (m PostureCheckDomainCreate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -181,6 +199,8 @@ func (m PostureCheckDomainCreate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -204,6 +224,10 @@ func (m *PostureCheckDomainCreate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -236,6 +260,22 @@ func (m *PostureCheckDomainCreate) validateName(formats strfmt.Registry) error { return nil } +func (m *PostureCheckDomainCreate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckDomainCreate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_domain_detail.go b/rest_model/posture_check_domain_detail.go index 8bc75502c..7f8831ed4 100644 --- a/rest_model/posture_check_domain_detail.go +++ b/rest_model/posture_check_domain_detail.go @@ -53,9 +53,9 @@ type PostureCheckDomainDetail struct { nameField *string - tagsField Tags + roleAttributesField Attributes - typeField *string + tagsField Tags updatedAtField *strfmt.DateTime @@ -117,6 +117,16 @@ func (m *PostureCheckDomainDetail) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckDomainDetail) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckDomainDetail) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckDomainDetail) Tags() Tags { return m.tagsField @@ -127,16 +137,6 @@ func (m *PostureCheckDomainDetail) SetTags(val Tags) { m.tagsField = val } -// Type gets the type of this subtype -func (m *PostureCheckDomainDetail) Type() *string { - return m.typeField -} - -// SetType sets the type of this subtype -func (m *PostureCheckDomainDetail) SetType(val *string) { - m.typeField = val -} - // TypeID gets the type Id of this subtype func (m *PostureCheckDomainDetail) TypeID() string { return "DOMAIN" @@ -196,9 +196,9 @@ func (m *PostureCheckDomainDetail) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -226,9 +226,9 @@ func (m *PostureCheckDomainDetail) UnmarshalJSON(raw []byte) error { result.nameField = base.Name - result.tagsField = base.Tags + result.roleAttributesField = base.RoleAttributes - result.typeField = base.Type + result.tagsField = base.Tags if base.TypeID != result.TypeID() { /* Not the type we're looking for. */ @@ -273,9 +273,9 @@ func (m PostureCheckDomainDetail) MarshalJSON() ([]byte, error) { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -294,9 +294,9 @@ func (m PostureCheckDomainDetail) MarshalJSON() ([]byte, error) { Name: m.Name(), - Tags: m.Tags(), + RoleAttributes: m.RoleAttributes(), - Type: m.Type(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -335,11 +335,11 @@ func (m *PostureCheckDomainDetail) Validate(formats strfmt.Registry) error { res = append(res, err) } - if err := m.validateTags(formats); err != nil { + if err := m.validateRoleAttributes(formats); err != nil { res = append(res, err) } - if err := m.validateType(formats); err != nil { + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -417,6 +417,22 @@ func (m *PostureCheckDomainDetail) validateName(formats strfmt.Registry) error { return nil } +func (m *PostureCheckDomainDetail) validateRoleAttributes(formats strfmt.Registry) error { + + if err := validate.Required("roleAttributes", "body", m.RoleAttributes()); err != nil { + return err + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckDomainDetail) validateTags(formats strfmt.Registry) error { if err := validate.Required("tags", "body", m.Tags()); err != nil { @@ -433,15 +449,6 @@ func (m *PostureCheckDomainDetail) validateTags(formats strfmt.Registry) error { return nil } -func (m *PostureCheckDomainDetail) validateType(formats strfmt.Registry) error { - - if err := validate.Required("type", "body", m.Type()); err != nil { - return err - } - - return nil -} - func (m *PostureCheckDomainDetail) validateUpdatedAt(formats strfmt.Registry) error { if err := validate.Required("updatedAt", "body", m.UpdatedAt()); err != nil { diff --git a/rest_model/posture_check_domain_patch.go b/rest_model/posture_check_domain_patch.go index 8ea019a99..b5cf24b45 100644 --- a/rest_model/posture_check_domain_patch.go +++ b/rest_model/posture_check_domain_patch.go @@ -47,6 +47,8 @@ type PostureCheckDomainPatch struct { nameField string + roleAttributesField Attributes + tagsField Tags // domains @@ -74,6 +76,16 @@ func (m *PostureCheckDomainPatch) SetName(val string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckDomainPatch) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckDomainPatch) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckDomainPatch) Tags() Tags { return m.tagsField @@ -107,6 +119,8 @@ func (m *PostureCheckDomainPatch) UnmarshalJSON(raw []byte) error { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` } buf = bytes.NewBuffer(raw) @@ -123,6 +137,8 @@ func (m *PostureCheckDomainPatch) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags result.Domains = data.Domains @@ -153,6 +169,8 @@ func (m PostureCheckDomainPatch) MarshalJSON() ([]byte, error) { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` }{ @@ -160,6 +178,8 @@ func (m PostureCheckDomainPatch) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), }) if err != nil { @@ -173,6 +193,10 @@ func (m PostureCheckDomainPatch) MarshalJSON() ([]byte, error) { func (m *PostureCheckDomainPatch) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -187,6 +211,22 @@ func (m *PostureCheckDomainPatch) Validate(formats strfmt.Registry) error { return nil } +func (m *PostureCheckDomainPatch) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckDomainPatch) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_domain_update.go b/rest_model/posture_check_domain_update.go index 1eb0bf2bc..39bbb89fd 100644 --- a/rest_model/posture_check_domain_update.go +++ b/rest_model/posture_check_domain_update.go @@ -47,6 +47,8 @@ type PostureCheckDomainUpdate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // domains @@ -75,6 +77,16 @@ func (m *PostureCheckDomainUpdate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckDomainUpdate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckDomainUpdate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckDomainUpdate) Tags() Tags { return m.tagsField @@ -118,6 +130,8 @@ func (m *PostureCheckDomainUpdate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -136,6 +150,8 @@ func (m *PostureCheckDomainUpdate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -172,6 +188,8 @@ func (m PostureCheckDomainUpdate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -181,6 +199,8 @@ func (m PostureCheckDomainUpdate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -204,6 +224,10 @@ func (m *PostureCheckDomainUpdate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -236,6 +260,22 @@ func (m *PostureCheckDomainUpdate) validateName(formats strfmt.Registry) error { return nil } +func (m *PostureCheckDomainUpdate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckDomainUpdate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_mac_address_create.go b/rest_model/posture_check_mac_address_create.go index dece2c83e..353423a43 100644 --- a/rest_model/posture_check_mac_address_create.go +++ b/rest_model/posture_check_mac_address_create.go @@ -47,6 +47,8 @@ type PostureCheckMacAddressCreate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // mac addresses @@ -75,6 +77,16 @@ func (m *PostureCheckMacAddressCreate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckMacAddressCreate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckMacAddressCreate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckMacAddressCreate) Tags() Tags { return m.tagsField @@ -118,6 +130,8 @@ func (m *PostureCheckMacAddressCreate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -136,6 +150,8 @@ func (m *PostureCheckMacAddressCreate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -172,6 +188,8 @@ func (m PostureCheckMacAddressCreate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -181,6 +199,8 @@ func (m PostureCheckMacAddressCreate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -204,6 +224,10 @@ func (m *PostureCheckMacAddressCreate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -236,6 +260,22 @@ func (m *PostureCheckMacAddressCreate) validateName(formats strfmt.Registry) err return nil } +func (m *PostureCheckMacAddressCreate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckMacAddressCreate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_mac_address_detail.go b/rest_model/posture_check_mac_address_detail.go index 02eb2ce2c..d9e9e07a7 100644 --- a/rest_model/posture_check_mac_address_detail.go +++ b/rest_model/posture_check_mac_address_detail.go @@ -53,9 +53,9 @@ type PostureCheckMacAddressDetail struct { nameField *string - tagsField Tags + roleAttributesField Attributes - typeField *string + tagsField Tags updatedAtField *strfmt.DateTime @@ -117,6 +117,16 @@ func (m *PostureCheckMacAddressDetail) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckMacAddressDetail) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckMacAddressDetail) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckMacAddressDetail) Tags() Tags { return m.tagsField @@ -127,16 +137,6 @@ func (m *PostureCheckMacAddressDetail) SetTags(val Tags) { m.tagsField = val } -// Type gets the type of this subtype -func (m *PostureCheckMacAddressDetail) Type() *string { - return m.typeField -} - -// SetType sets the type of this subtype -func (m *PostureCheckMacAddressDetail) SetType(val *string) { - m.typeField = val -} - // TypeID gets the type Id of this subtype func (m *PostureCheckMacAddressDetail) TypeID() string { return "MAC" @@ -196,9 +196,9 @@ func (m *PostureCheckMacAddressDetail) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -226,9 +226,9 @@ func (m *PostureCheckMacAddressDetail) UnmarshalJSON(raw []byte) error { result.nameField = base.Name - result.tagsField = base.Tags + result.roleAttributesField = base.RoleAttributes - result.typeField = base.Type + result.tagsField = base.Tags if base.TypeID != result.TypeID() { /* Not the type we're looking for. */ @@ -273,9 +273,9 @@ func (m PostureCheckMacAddressDetail) MarshalJSON() ([]byte, error) { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -294,9 +294,9 @@ func (m PostureCheckMacAddressDetail) MarshalJSON() ([]byte, error) { Name: m.Name(), - Tags: m.Tags(), + RoleAttributes: m.RoleAttributes(), - Type: m.Type(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -335,11 +335,11 @@ func (m *PostureCheckMacAddressDetail) Validate(formats strfmt.Registry) error { res = append(res, err) } - if err := m.validateTags(formats); err != nil { + if err := m.validateRoleAttributes(formats); err != nil { res = append(res, err) } - if err := m.validateType(formats); err != nil { + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -417,6 +417,22 @@ func (m *PostureCheckMacAddressDetail) validateName(formats strfmt.Registry) err return nil } +func (m *PostureCheckMacAddressDetail) validateRoleAttributes(formats strfmt.Registry) error { + + if err := validate.Required("roleAttributes", "body", m.RoleAttributes()); err != nil { + return err + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckMacAddressDetail) validateTags(formats strfmt.Registry) error { if err := validate.Required("tags", "body", m.Tags()); err != nil { @@ -433,15 +449,6 @@ func (m *PostureCheckMacAddressDetail) validateTags(formats strfmt.Registry) err return nil } -func (m *PostureCheckMacAddressDetail) validateType(formats strfmt.Registry) error { - - if err := validate.Required("type", "body", m.Type()); err != nil { - return err - } - - return nil -} - func (m *PostureCheckMacAddressDetail) validateUpdatedAt(formats strfmt.Registry) error { if err := validate.Required("updatedAt", "body", m.UpdatedAt()); err != nil { diff --git a/rest_model/posture_check_mac_address_patch.go b/rest_model/posture_check_mac_address_patch.go index b67bdd654..86392e788 100644 --- a/rest_model/posture_check_mac_address_patch.go +++ b/rest_model/posture_check_mac_address_patch.go @@ -47,6 +47,8 @@ type PostureCheckMacAddressPatch struct { nameField string + roleAttributesField Attributes + tagsField Tags // mac addresses @@ -74,6 +76,16 @@ func (m *PostureCheckMacAddressPatch) SetName(val string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckMacAddressPatch) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckMacAddressPatch) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckMacAddressPatch) Tags() Tags { return m.tagsField @@ -107,6 +119,8 @@ func (m *PostureCheckMacAddressPatch) UnmarshalJSON(raw []byte) error { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` } buf = bytes.NewBuffer(raw) @@ -123,6 +137,8 @@ func (m *PostureCheckMacAddressPatch) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags result.MacAddresses = data.MacAddresses @@ -153,6 +169,8 @@ func (m PostureCheckMacAddressPatch) MarshalJSON() ([]byte, error) { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` }{ @@ -160,6 +178,8 @@ func (m PostureCheckMacAddressPatch) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), }) if err != nil { @@ -173,6 +193,10 @@ func (m PostureCheckMacAddressPatch) MarshalJSON() ([]byte, error) { func (m *PostureCheckMacAddressPatch) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -187,6 +211,22 @@ func (m *PostureCheckMacAddressPatch) Validate(formats strfmt.Registry) error { return nil } +func (m *PostureCheckMacAddressPatch) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckMacAddressPatch) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_mac_address_update.go b/rest_model/posture_check_mac_address_update.go index 0cc7a41e4..c5a222e1b 100644 --- a/rest_model/posture_check_mac_address_update.go +++ b/rest_model/posture_check_mac_address_update.go @@ -47,6 +47,8 @@ type PostureCheckMacAddressUpdate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // mac addresses @@ -75,6 +77,16 @@ func (m *PostureCheckMacAddressUpdate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckMacAddressUpdate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckMacAddressUpdate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckMacAddressUpdate) Tags() Tags { return m.tagsField @@ -118,6 +130,8 @@ func (m *PostureCheckMacAddressUpdate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -136,6 +150,8 @@ func (m *PostureCheckMacAddressUpdate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -172,6 +188,8 @@ func (m PostureCheckMacAddressUpdate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -181,6 +199,8 @@ func (m PostureCheckMacAddressUpdate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -204,6 +224,10 @@ func (m *PostureCheckMacAddressUpdate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -236,6 +260,22 @@ func (m *PostureCheckMacAddressUpdate) validateName(formats strfmt.Registry) err return nil } +func (m *PostureCheckMacAddressUpdate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckMacAddressUpdate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_operating_system_create.go b/rest_model/posture_check_operating_system_create.go index d197de622..3ed7bf4b1 100644 --- a/rest_model/posture_check_operating_system_create.go +++ b/rest_model/posture_check_operating_system_create.go @@ -47,6 +47,8 @@ type PostureCheckOperatingSystemCreate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // operating systems @@ -74,6 +76,16 @@ func (m *PostureCheckOperatingSystemCreate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckOperatingSystemCreate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckOperatingSystemCreate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckOperatingSystemCreate) Tags() Tags { return m.tagsField @@ -116,6 +128,8 @@ func (m *PostureCheckOperatingSystemCreate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -134,6 +148,8 @@ func (m *PostureCheckOperatingSystemCreate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -169,6 +185,8 @@ func (m PostureCheckOperatingSystemCreate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -178,6 +196,8 @@ func (m PostureCheckOperatingSystemCreate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -201,6 +221,10 @@ func (m *PostureCheckOperatingSystemCreate) Validate(formats strfmt.Registry) er res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -233,6 +257,22 @@ func (m *PostureCheckOperatingSystemCreate) validateName(formats strfmt.Registry return nil } +func (m *PostureCheckOperatingSystemCreate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckOperatingSystemCreate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_operating_system_detail.go b/rest_model/posture_check_operating_system_detail.go index 3be6299cb..3feaa597d 100644 --- a/rest_model/posture_check_operating_system_detail.go +++ b/rest_model/posture_check_operating_system_detail.go @@ -53,9 +53,9 @@ type PostureCheckOperatingSystemDetail struct { nameField *string - tagsField Tags + roleAttributesField Attributes - typeField *string + tagsField Tags updatedAtField *strfmt.DateTime @@ -116,6 +116,16 @@ func (m *PostureCheckOperatingSystemDetail) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckOperatingSystemDetail) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckOperatingSystemDetail) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckOperatingSystemDetail) Tags() Tags { return m.tagsField @@ -126,16 +136,6 @@ func (m *PostureCheckOperatingSystemDetail) SetTags(val Tags) { m.tagsField = val } -// Type gets the type of this subtype -func (m *PostureCheckOperatingSystemDetail) Type() *string { - return m.typeField -} - -// SetType sets the type of this subtype -func (m *PostureCheckOperatingSystemDetail) SetType(val *string) { - m.typeField = val -} - // TypeID gets the type Id of this subtype func (m *PostureCheckOperatingSystemDetail) TypeID() string { return "OS" @@ -194,9 +194,9 @@ func (m *PostureCheckOperatingSystemDetail) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -224,9 +224,9 @@ func (m *PostureCheckOperatingSystemDetail) UnmarshalJSON(raw []byte) error { result.nameField = base.Name - result.tagsField = base.Tags + result.roleAttributesField = base.RoleAttributes - result.typeField = base.Type + result.tagsField = base.Tags if base.TypeID != result.TypeID() { /* Not the type we're looking for. */ @@ -270,9 +270,9 @@ func (m PostureCheckOperatingSystemDetail) MarshalJSON() ([]byte, error) { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -291,9 +291,9 @@ func (m PostureCheckOperatingSystemDetail) MarshalJSON() ([]byte, error) { Name: m.Name(), - Tags: m.Tags(), + RoleAttributes: m.RoleAttributes(), - Type: m.Type(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -332,11 +332,11 @@ func (m *PostureCheckOperatingSystemDetail) Validate(formats strfmt.Registry) er res = append(res, err) } - if err := m.validateTags(formats); err != nil { + if err := m.validateRoleAttributes(formats); err != nil { res = append(res, err) } - if err := m.validateType(formats); err != nil { + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -414,6 +414,22 @@ func (m *PostureCheckOperatingSystemDetail) validateName(formats strfmt.Registry return nil } +func (m *PostureCheckOperatingSystemDetail) validateRoleAttributes(formats strfmt.Registry) error { + + if err := validate.Required("roleAttributes", "body", m.RoleAttributes()); err != nil { + return err + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckOperatingSystemDetail) validateTags(formats strfmt.Registry) error { if err := validate.Required("tags", "body", m.Tags()); err != nil { @@ -430,15 +446,6 @@ func (m *PostureCheckOperatingSystemDetail) validateTags(formats strfmt.Registry return nil } -func (m *PostureCheckOperatingSystemDetail) validateType(formats strfmt.Registry) error { - - if err := validate.Required("type", "body", m.Type()); err != nil { - return err - } - - return nil -} - func (m *PostureCheckOperatingSystemDetail) validateUpdatedAt(formats strfmt.Registry) error { if err := validate.Required("updatedAt", "body", m.UpdatedAt()); err != nil { diff --git a/rest_model/posture_check_operating_system_patch.go b/rest_model/posture_check_operating_system_patch.go index 2f5cc8d2e..174a30141 100644 --- a/rest_model/posture_check_operating_system_patch.go +++ b/rest_model/posture_check_operating_system_patch.go @@ -46,6 +46,8 @@ type PostureCheckOperatingSystemPatch struct { nameField string + roleAttributesField Attributes + tagsField Tags // operating systems @@ -72,6 +74,16 @@ func (m *PostureCheckOperatingSystemPatch) SetName(val string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckOperatingSystemPatch) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckOperatingSystemPatch) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckOperatingSystemPatch) Tags() Tags { return m.tagsField @@ -104,6 +116,8 @@ func (m *PostureCheckOperatingSystemPatch) UnmarshalJSON(raw []byte) error { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` } buf = bytes.NewBuffer(raw) @@ -120,6 +134,8 @@ func (m *PostureCheckOperatingSystemPatch) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags result.OperatingSystems = data.OperatingSystems @@ -149,6 +165,8 @@ func (m PostureCheckOperatingSystemPatch) MarshalJSON() ([]byte, error) { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` }{ @@ -156,6 +174,8 @@ func (m PostureCheckOperatingSystemPatch) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), }) if err != nil { @@ -169,6 +189,10 @@ func (m PostureCheckOperatingSystemPatch) MarshalJSON() ([]byte, error) { func (m *PostureCheckOperatingSystemPatch) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -183,6 +207,22 @@ func (m *PostureCheckOperatingSystemPatch) Validate(formats strfmt.Registry) err return nil } +func (m *PostureCheckOperatingSystemPatch) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckOperatingSystemPatch) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_operating_system_update.go b/rest_model/posture_check_operating_system_update.go index 8dbe1b773..0a73829b0 100644 --- a/rest_model/posture_check_operating_system_update.go +++ b/rest_model/posture_check_operating_system_update.go @@ -47,6 +47,8 @@ type PostureCheckOperatingSystemUpdate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // operating systems @@ -74,6 +76,16 @@ func (m *PostureCheckOperatingSystemUpdate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckOperatingSystemUpdate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckOperatingSystemUpdate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckOperatingSystemUpdate) Tags() Tags { return m.tagsField @@ -116,6 +128,8 @@ func (m *PostureCheckOperatingSystemUpdate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -134,6 +148,8 @@ func (m *PostureCheckOperatingSystemUpdate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -169,6 +185,8 @@ func (m PostureCheckOperatingSystemUpdate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -178,6 +196,8 @@ func (m PostureCheckOperatingSystemUpdate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -201,6 +221,10 @@ func (m *PostureCheckOperatingSystemUpdate) Validate(formats strfmt.Registry) er res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -233,6 +257,22 @@ func (m *PostureCheckOperatingSystemUpdate) validateName(formats strfmt.Registry return nil } +func (m *PostureCheckOperatingSystemUpdate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckOperatingSystemUpdate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_patch.go b/rest_model/posture_check_patch.go index 1f95887e0..7a2c3d193 100644 --- a/rest_model/posture_check_patch.go +++ b/rest_model/posture_check_patch.go @@ -56,6 +56,10 @@ type PostureCheckPatch interface { Name() string SetName(string) + // role attributes + RoleAttributes() Attributes + SetRoleAttributes(Attributes) + // tags Tags() Tags SetTags(Tags) @@ -69,6 +73,8 @@ type postureCheckPatch struct { nameField string + roleAttributesField Attributes + tagsField Tags } @@ -92,6 +98,16 @@ func (m *postureCheckPatch) SetName(val string) { m.nameField = val } +// RoleAttributes gets the role attributes of this polymorphic type +func (m *postureCheckPatch) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this polymorphic type +func (m *postureCheckPatch) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this polymorphic type func (m *postureCheckPatch) Tags() Tags { return m.tagsField @@ -186,6 +202,10 @@ func unmarshalPostureCheckPatch(data []byte, consumer runtime.Consumer) (Posture func (m *postureCheckPatch) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -196,6 +216,22 @@ func (m *postureCheckPatch) Validate(formats strfmt.Registry) error { return nil } +func (m *postureCheckPatch) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *postureCheckPatch) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_process_create.go b/rest_model/posture_check_process_create.go index dd1803955..7b67aed9e 100644 --- a/rest_model/posture_check_process_create.go +++ b/rest_model/posture_check_process_create.go @@ -47,6 +47,8 @@ type PostureCheckProcessCreate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // process @@ -74,6 +76,16 @@ func (m *PostureCheckProcessCreate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckProcessCreate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckProcessCreate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckProcessCreate) Tags() Tags { return m.tagsField @@ -116,6 +128,8 @@ func (m *PostureCheckProcessCreate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -134,6 +148,8 @@ func (m *PostureCheckProcessCreate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -169,6 +185,8 @@ func (m PostureCheckProcessCreate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId"` @@ -178,6 +196,8 @@ func (m PostureCheckProcessCreate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -201,6 +221,10 @@ func (m *PostureCheckProcessCreate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -233,6 +257,22 @@ func (m *PostureCheckProcessCreate) validateName(formats strfmt.Registry) error return nil } +func (m *PostureCheckProcessCreate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckProcessCreate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_process_detail.go b/rest_model/posture_check_process_detail.go index 428d8cab7..e13af7f08 100644 --- a/rest_model/posture_check_process_detail.go +++ b/rest_model/posture_check_process_detail.go @@ -53,9 +53,9 @@ type PostureCheckProcessDetail struct { nameField *string - tagsField Tags + roleAttributesField Attributes - typeField *string + tagsField Tags updatedAtField *strfmt.DateTime @@ -116,6 +116,16 @@ func (m *PostureCheckProcessDetail) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckProcessDetail) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckProcessDetail) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckProcessDetail) Tags() Tags { return m.tagsField @@ -126,16 +136,6 @@ func (m *PostureCheckProcessDetail) SetTags(val Tags) { m.tagsField = val } -// Type gets the type of this subtype -func (m *PostureCheckProcessDetail) Type() *string { - return m.typeField -} - -// SetType sets the type of this subtype -func (m *PostureCheckProcessDetail) SetType(val *string) { - m.typeField = val -} - // TypeID gets the type Id of this subtype func (m *PostureCheckProcessDetail) TypeID() string { return "PROCESS" @@ -194,9 +194,9 @@ func (m *PostureCheckProcessDetail) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -224,9 +224,9 @@ func (m *PostureCheckProcessDetail) UnmarshalJSON(raw []byte) error { result.nameField = base.Name - result.tagsField = base.Tags + result.roleAttributesField = base.RoleAttributes - result.typeField = base.Type + result.tagsField = base.Tags if base.TypeID != result.TypeID() { /* Not the type we're looking for. */ @@ -270,9 +270,9 @@ func (m PostureCheckProcessDetail) MarshalJSON() ([]byte, error) { Name *string `json:"name"` - Tags Tags `json:"tags"` + RoleAttributes Attributes `json:"roleAttributes"` - Type *string `json:"type"` + Tags Tags `json:"tags"` TypeID string `json:"typeId"` @@ -291,9 +291,9 @@ func (m PostureCheckProcessDetail) MarshalJSON() ([]byte, error) { Name: m.Name(), - Tags: m.Tags(), + RoleAttributes: m.RoleAttributes(), - Type: m.Type(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -332,11 +332,11 @@ func (m *PostureCheckProcessDetail) Validate(formats strfmt.Registry) error { res = append(res, err) } - if err := m.validateTags(formats); err != nil { + if err := m.validateRoleAttributes(formats); err != nil { res = append(res, err) } - if err := m.validateType(formats); err != nil { + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -414,6 +414,22 @@ func (m *PostureCheckProcessDetail) validateName(formats strfmt.Registry) error return nil } +func (m *PostureCheckProcessDetail) validateRoleAttributes(formats strfmt.Registry) error { + + if err := validate.Required("roleAttributes", "body", m.RoleAttributes()); err != nil { + return err + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckProcessDetail) validateTags(formats strfmt.Registry) error { if err := validate.Required("tags", "body", m.Tags()); err != nil { @@ -430,15 +446,6 @@ func (m *PostureCheckProcessDetail) validateTags(formats strfmt.Registry) error return nil } -func (m *PostureCheckProcessDetail) validateType(formats strfmt.Registry) error { - - if err := validate.Required("type", "body", m.Type()); err != nil { - return err - } - - return nil -} - func (m *PostureCheckProcessDetail) validateUpdatedAt(formats strfmt.Registry) error { if err := validate.Required("updatedAt", "body", m.UpdatedAt()); err != nil { diff --git a/rest_model/posture_check_process_patch.go b/rest_model/posture_check_process_patch.go index d1569e77d..704f4794b 100644 --- a/rest_model/posture_check_process_patch.go +++ b/rest_model/posture_check_process_patch.go @@ -46,6 +46,8 @@ type PostureCheckProcessPatch struct { nameField string + roleAttributesField Attributes + tagsField Tags // process @@ -72,6 +74,16 @@ func (m *PostureCheckProcessPatch) SetName(val string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckProcessPatch) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckProcessPatch) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckProcessPatch) Tags() Tags { return m.tagsField @@ -104,6 +116,8 @@ func (m *PostureCheckProcessPatch) UnmarshalJSON(raw []byte) error { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` } buf = bytes.NewBuffer(raw) @@ -120,6 +134,8 @@ func (m *PostureCheckProcessPatch) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags result.Process = data.Process @@ -149,6 +165,8 @@ func (m PostureCheckProcessPatch) MarshalJSON() ([]byte, error) { Name string `json:"name,omitempty"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` }{ @@ -156,6 +174,8 @@ func (m PostureCheckProcessPatch) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), }) if err != nil { @@ -169,6 +189,10 @@ func (m PostureCheckProcessPatch) MarshalJSON() ([]byte, error) { func (m *PostureCheckProcessPatch) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -183,6 +207,22 @@ func (m *PostureCheckProcessPatch) Validate(formats strfmt.Registry) error { return nil } +func (m *PostureCheckProcessPatch) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckProcessPatch) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_process_update.go b/rest_model/posture_check_process_update.go index 5302fb59e..3fc83920f 100644 --- a/rest_model/posture_check_process_update.go +++ b/rest_model/posture_check_process_update.go @@ -47,6 +47,8 @@ type PostureCheckProcessUpdate struct { nameField *string + roleAttributesField Attributes + tagsField Tags // process @@ -74,6 +76,16 @@ func (m *PostureCheckProcessUpdate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this subtype +func (m *PostureCheckProcessUpdate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this subtype +func (m *PostureCheckProcessUpdate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this subtype func (m *PostureCheckProcessUpdate) Tags() Tags { return m.tagsField @@ -116,6 +128,8 @@ func (m *PostureCheckProcessUpdate) UnmarshalJSON(raw []byte) error { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -134,6 +148,8 @@ func (m *PostureCheckProcessUpdate) UnmarshalJSON(raw []byte) error { result.nameField = base.Name + result.roleAttributesField = base.RoleAttributes + result.tagsField = base.Tags if base.TypeID != result.TypeID() { @@ -169,6 +185,8 @@ func (m PostureCheckProcessUpdate) MarshalJSON() ([]byte, error) { Name *string `json:"name"` + RoleAttributes Attributes `json:"roleAttributes"` + Tags Tags `json:"tags"` TypeID PostureCheckType `json:"typeId,omitempty"` @@ -178,6 +196,8 @@ func (m PostureCheckProcessUpdate) MarshalJSON() ([]byte, error) { Name: m.Name(), + RoleAttributes: m.RoleAttributes(), + Tags: m.Tags(), TypeID: m.TypeID(), @@ -201,6 +221,10 @@ func (m *PostureCheckProcessUpdate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -233,6 +257,22 @@ func (m *PostureCheckProcessUpdate) validateName(formats strfmt.Registry) error return nil } +func (m *PostureCheckProcessUpdate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *PostureCheckProcessUpdate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/posture_check_update.go b/rest_model/posture_check_update.go index 3f5f0514f..5930e1641 100644 --- a/rest_model/posture_check_update.go +++ b/rest_model/posture_check_update.go @@ -58,6 +58,10 @@ type PostureCheckUpdate interface { Name() *string SetName(*string) + // role attributes + RoleAttributes() Attributes + SetRoleAttributes(Attributes) + // tags Tags() Tags SetTags(Tags) @@ -75,6 +79,8 @@ type postureCheckUpdate struct { nameField *string + roleAttributesField Attributes + tagsField Tags typeIdField PostureCheckType @@ -100,6 +106,16 @@ func (m *postureCheckUpdate) SetName(val *string) { m.nameField = val } +// RoleAttributes gets the role attributes of this polymorphic type +func (m *postureCheckUpdate) RoleAttributes() Attributes { + return m.roleAttributesField +} + +// SetRoleAttributes sets the role attributes of this polymorphic type +func (m *postureCheckUpdate) SetRoleAttributes(val Attributes) { + m.roleAttributesField = val +} + // Tags gets the tags of this polymorphic type func (m *postureCheckUpdate) Tags() Tags { return m.tagsField @@ -211,6 +227,10 @@ func (m *postureCheckUpdate) Validate(formats strfmt.Registry) error { res = append(res, err) } + if err := m.validateRoleAttributes(formats); err != nil { + res = append(res, err) + } + if err := m.validateTags(formats); err != nil { res = append(res, err) } @@ -239,6 +259,22 @@ func (m *postureCheckUpdate) validateName(formats strfmt.Registry) error { return nil } +func (m *postureCheckUpdate) validateRoleAttributes(formats strfmt.Registry) error { + + if swag.IsZero(m.RoleAttributes()) { // not required + return nil + } + + if err := m.RoleAttributes().Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("roleAttributes") + } + return err + } + + return nil +} + func (m *postureCheckUpdate) validateTags(formats strfmt.Registry) error { if swag.IsZero(m.Tags()) { // not required diff --git a/rest_model/service_create.go b/rest_model/service_create.go index 0c8652259..b6cf3fefa 100644 --- a/rest_model/service_create.go +++ b/rest_model/service_create.go @@ -45,7 +45,8 @@ type ServiceCreate struct { Configs []string `json:"configs"` // encryption required - EncryptionRequired bool `json:"encryptionRequired,omitempty"` + // Required: true + EncryptionRequired *bool `json:"encryptionRequired"` // name // Required: true @@ -65,6 +66,10 @@ type ServiceCreate struct { func (m *ServiceCreate) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateEncryptionRequired(formats); err != nil { + res = append(res, err) + } + if err := m.validateName(formats); err != nil { res = append(res, err) } @@ -79,6 +84,15 @@ func (m *ServiceCreate) Validate(formats strfmt.Registry) error { return nil } +func (m *ServiceCreate) validateEncryptionRequired(formats strfmt.Registry) error { + + if err := validate.Required("encryptionRequired", "body", m.EncryptionRequired); err != nil { + return err + } + + return nil +} + func (m *ServiceCreate) validateName(formats strfmt.Registry) error { if err := validate.Required("name", "body", m.Name); err != nil { diff --git a/rest_server/embedded_spec.go b/rest_server/embedded_spec.go index 94d56dcbb..b94baa022 100644 --- a/rest_server/embedded_spec.go +++ b/rest_server/embedded_spec.go @@ -4878,6 +4878,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, @@ -4891,10 +4894,10 @@ func init() { "type": "object", "required": [ "name", - "type", "typeId", "description", "version", + "roleAttributes", "id", "createdAt", "updatedAt", @@ -4918,12 +4921,12 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, - "type": { - "type": "string" - }, "typeId": { "type": "string" }, @@ -5203,6 +5206,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" } @@ -5327,6 +5333,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, @@ -7997,7 +8006,8 @@ func init() { "serviceCreate": { "type": "object", "required": [ - "name" + "name", + "encryptionRequired" ], "properties": { "configs": { @@ -22192,6 +22202,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, @@ -22205,10 +22218,10 @@ func init() { "type": "object", "required": [ "name", - "type", "typeId", "description", "version", + "roleAttributes", "id", "createdAt", "updatedAt", @@ -22232,12 +22245,12 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, - "type": { - "type": "string" - }, "typeId": { "type": "string" }, @@ -22517,6 +22530,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" } @@ -22641,6 +22657,9 @@ func init() { "name": { "type": "string" }, + "roleAttributes": { + "$ref": "#/definitions/attributes" + }, "tags": { "$ref": "#/definitions/tags" }, @@ -25311,7 +25330,8 @@ func init() { "serviceCreate": { "type": "object", "required": [ - "name" + "name", + "encryptionRequired" ], "properties": { "configs": { diff --git a/specs/swagger.yml b/specs/swagger.yml index 46f482be5..debffa387 100644 --- a/specs/swagger.yml +++ b/specs/swagger.yml @@ -4925,6 +4925,7 @@ definitions: type: object required: - name + - encryptionRequired properties: name: type: string @@ -6213,10 +6214,10 @@ definitions: # see https://github.com/go-swagger/go-swagger/issues/2413 required: - name - - type - typeId - description - version + - roleAttributes - id - createdAt - updatedAt @@ -6225,14 +6226,14 @@ definitions: properties: name: type: string - type: - type: string typeId: type: string description: type: string version: type: integer + roleAttributes: + $ref: '#/definitions/attributes' id: type: string createdAt: @@ -6259,6 +6260,8 @@ definitions: $ref: '#/definitions/postureCheckType' description: type: string + roleAttributes: + $ref: '#/definitions/attributes' tags: $ref: '#/definitions/tags' PostureCheckUpdate: @@ -6274,6 +6277,8 @@ definitions: $ref: '#/definitions/postureCheckType' description: type: string + roleAttributes: + $ref: '#/definitions/attributes' tags: $ref: '#/definitions/tags' PostureCheckPatch: @@ -6284,6 +6289,8 @@ definitions: type: string description: type: string + roleAttributes: + $ref: '#/definitions/attributes' tags: $ref: '#/definitions/tags' diff --git a/tests/context.go b/tests/context.go index 81552d356..fe2ca5abe 100644 --- a/tests/context.go +++ b/tests/context.go @@ -538,6 +538,7 @@ func (ctx *TestContext) newService(roleAttributes, configs []string) *service { terminatorStrategy: xt_smartrouting.Name, roleAttributes: roleAttributes, configs: configs, + encryptionRequired: false, tags: nil, } } diff --git a/tests/entities.go b/tests/entities.go index 5e3f0ac0f..c7f299cd2 100644 --- a/tests/entities.go +++ b/tests/entities.go @@ -52,6 +52,7 @@ type service struct { configs []string permissions []string tags map[string]interface{} + encryptionRequired bool } func (entity *service) getId() string { @@ -72,6 +73,7 @@ func (entity *service) toJson(_ bool, ctx *TestContext, _ ...string) string { ctx.setJsonValue(entityData, entity.terminatorStrategy, "terminatorStrategy") ctx.setJsonValue(entityData, entity.roleAttributes, "roleAttributes") ctx.setJsonValue(entityData, entity.configs, "configs") + ctx.setJsonValue(entityData, entity.encryptionRequired, "encryptionRequired") if len(entity.tags) > 0 { ctx.setJsonValue(entityData, entity.tags, "tags")