DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Regen controllers, remove resputil

Browse Source
This commit is contained in:
Denis Arh
2020-11-12 19:58:55 +01:00
committed by Peter Grlica
parent 277df45b65
commit 4f69ad8cdb
20 changed files with 1346 additions and 2460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
federation/rest/handlers/manageStructure.go
View File

@@ -10,12 +10,10 @@ package handlers
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/cortezaproject/corteza-server/pkg/api"
"github.com/go-chi/chi"
"net/http"
)
type (
@@ -50,161 +48,129 @@ func NewManageStructure(h ManageStructureAPI) *ManageStructure {
defer r.Body.Close()
params := request.NewManageStructureReadExposed()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.ReadExposed", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadExposed(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.ReadExposed", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.ReadExposed", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
CreateExposed: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureCreateExposed()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.CreateExposed", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.CreateExposed(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.CreateExposed", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.CreateExposed", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
UpdateExposed: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureUpdateExposed()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.UpdateExposed", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.UpdateExposed(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.UpdateExposed", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.UpdateExposed", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
RemoveExposed: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureRemoveExposed()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.RemoveExposed", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.RemoveExposed(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.RemoveExposed", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.RemoveExposed", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
ReadShared: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureReadShared()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.ReadShared", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadShared(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.ReadShared", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.ReadShared", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
CreateMappings: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureCreateMappings()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.CreateMappings", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.CreateMappings(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.CreateMappings", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.CreateMappings", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
ReadMappings: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureReadMappings()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.ReadMappings", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadMappings(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.ReadMappings", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.ReadMappings", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
ListAll: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewManageStructureListAll()
if err := params.Fill(r); err != nil {
logger.LogParamError("ManageStructure.ListAll", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ListAll(r.Context(), params)
if err != nil {
logger.LogControllerError("ManageStructure.ListAll", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("ManageStructure.ListAll", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
}
}

128
federation/rest/handlers/node.go
View File

@@ -10,12 +10,10 @@ package handlers
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/cortezaproject/corteza-server/pkg/api"
"github.com/go-chi/chi"
"net/http"
)
type (
@@ -54,201 +52,161 @@ func NewNode(h NodeAPI) *Node {
defer r.Body.Close()
params := request.NewNodeSearch()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Search", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Search(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Search", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Search", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Create: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeCreate()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Create", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Create(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Create", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Create", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Read: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeRead()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Read", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Read(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Read", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Read", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
GenerateURI: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeGenerateURI()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.GenerateURI", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.GenerateURI(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.GenerateURI", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.GenerateURI", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Update: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeUpdate()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Update", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Update(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Update", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Update", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Delete: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeDelete()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Delete", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Delete(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Delete", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Delete", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Undelete: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeUndelete()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Undelete", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Undelete(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Undelete", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Undelete", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
Pair: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodePair()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.Pair", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Pair(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.Pair", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.Pair", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
HandshakeConfirm: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeHandshakeConfirm()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.HandshakeConfirm", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.HandshakeConfirm(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.HandshakeConfirm", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.HandshakeConfirm", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
HandshakeComplete: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewNodeHandshakeComplete()
if err := params.Fill(r); err != nil {
logger.LogParamError("Node.HandshakeComplete", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.HandshakeComplete(r.Context(), params)
if err != nil {
logger.LogControllerError("Node.HandshakeComplete", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("Node.HandshakeComplete", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
}
}

20
federation/rest/handlers/nodeHandshake.go
View File

@@ -10,12 +10,10 @@ package handlers
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/cortezaproject/corteza-server/pkg/api"
"github.com/go-chi/chi"
"net/http"
)
type (
@@ -36,21 +34,17 @@ func NewNodeHandshake(h NodeHandshakeAPI) *NodeHandshake {
defer r.Body.Close()
params := request.NewNodeHandshakeInitialize()
if err := params.Fill(r); err != nil {
logger.LogParamError("NodeHandshake.Initialize", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.Initialize(r.Context(), params)
if err != nil {
logger.LogControllerError("NodeHandshake.Initialize", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("NodeHandshake.Initialize", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
}
}

86
federation/rest/handlers/pair.go
View File

@@ -1,86 +0,0 @@
package handlers
// This file is auto-generated.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// Definitions file that controls how this file is generated:
//
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
)
type (
// Internal API interface
PairAPI interface {
ApprovePairing(context.Context, *request.PairApprovePairing) (interface{}, error)
CompletePairing(context.Context, *request.PairCompletePairing) (interface{}, error)
}
// HTTP API interface
Pair struct {
ApprovePairing func(http.ResponseWriter, *http.Request)
CompletePairing func(http.ResponseWriter, *http.Request)
}
)
func NewPair(h PairAPI) *Pair {
return &Pair{
ApprovePairing: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewPairApprovePairing()
if err := params.Fill(r); err != nil {
logger.LogParamError("Pair.ApprovePairing", r, err)
resputil.JSON(w, err)
return
}
value, err := h.ApprovePairing(r.Context(), params)
if err != nil {
logger.LogControllerError("Pair.ApprovePairing", r, err, params.Auditable())
resputil.JSON(w, err)
return
}
logger.LogControllerCall("Pair.ApprovePairing", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
},
CompletePairing: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewPairCompletePairing()
if err := params.Fill(r); err != nil {
logger.LogParamError("Pair.CompletePairing", r, err)
resputil.JSON(w, err)
return
}
value, err := h.CompletePairing(r.Context(), params)
if err != nil {
logger.LogControllerError("Pair.CompletePairing", r, err, params.Auditable())
resputil.JSON(w, err)
return
}
logger.LogControllerCall("Pair.CompletePairing", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
},
}
}
func (h Pair) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
r.Group(func(r chi.Router) {
r.Use(middlewares...)
r.Post("/node/pair/approve", h.ApprovePairing)
r.Post("/node/pair/complete", h.CompletePairing)
})
}

32
federation/rest/handlers/syncData.go
View File

@@ -10,12 +10,10 @@ package handlers
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/cortezaproject/corteza-server/pkg/api"
"github.com/go-chi/chi"
"net/http"
)
type (
@@ -38,41 +36,33 @@ func NewSyncData(h SyncDataAPI) *SyncData {
defer r.Body.Close()
params := request.NewSyncDataReadExposedAll()
if err := params.Fill(r); err != nil {
logger.LogParamError("SyncData.ReadExposedAll", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadExposedAll(r.Context(), params)
if err != nil {
logger.LogControllerError("SyncData.ReadExposedAll", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("SyncData.ReadExposedAll", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
ReadExposed: func(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
params := request.NewSyncDataReadExposed()
if err := params.Fill(r); err != nil {
logger.LogParamError("SyncData.ReadExposed", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadExposed(r.Context(), params)
if err != nil {
logger.LogControllerError("SyncData.ReadExposed", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("SyncData.ReadExposed", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
}
}

20
federation/rest/handlers/syncStructure.go
View File

@@ -10,12 +10,10 @@ package handlers
import (
"context"
"github.com/go-chi/chi"
"github.com/titpetric/factory/resputil"
"net/http"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/cortezaproject/corteza-server/pkg/api"
"github.com/go-chi/chi"
"net/http"
)
type (
@@ -36,21 +34,17 @@ func NewSyncStructure(h SyncStructureAPI) *SyncStructure {
defer r.Body.Close()
params := request.NewSyncStructureReadExposedAll()
if err := params.Fill(r); err != nil {
logger.LogParamError("SyncStructure.ReadExposedAll", r, err)
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
value, err := h.ReadExposedAll(r.Context(), params)
if err != nil {
logger.LogControllerError("SyncStructure.ReadExposedAll", r, err, params.Auditable())
resputil.JSON(w, err)
api.Send(w, r, err)
return
}
logger.LogControllerCall("SyncStructure.ReadExposedAll", r, params.Auditable())
if !serveHTTP(value, w, r) {
resputil.JSON(w, value)
}
api.Send(w, r, value)
},
}
}

17
federation/rest/handlers/util.go
View File

@@ -1,17 +0,0 @@
package handlers
import (
"net/http"
)
// Edit this file in `codegen/common/rest/handlers/util.go`;
// any changes under [service] will be overwritten by codegen.
func serveHTTP(value interface{}, w http.ResponseWriter, r *http.Request) bool {
switch fn := value.(type) {
case func(http.ResponseWriter, *http.Request):
fn(w, r)
return true
}
return false
}

13
federation/rest/node.go
View File

@@ -2,11 +2,10 @@ package rest
import (
"context"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/federation/service"
"github.com/cortezaproject/corteza-server/federation/types"
"github.com/titpetric/factory/resputil"
"github.com/cortezaproject/corteza-server/pkg/api"
)
type (
@@ -84,11 +83,11 @@ func (ctrl Node) Update(ctx context.Context, r *request.NodeUpdate) (interface{}
return ctrl.makePayload(ctx, n, err)
}
func (ctrl Node) Delete(ctx context.Context, r *request.NodeDelete) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.DeleteByID(ctx, r.NodeID)
return api.OK(), ctrl.svcNode.DeleteByID(ctx, r.NodeID)
}
func (ctrl Node) Undelete(ctx context.Context, r *request.NodeUndelete) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.UndeleteByID(ctx, r.NodeID)
return api.OK(), ctrl.svcNode.UndeleteByID(ctx, r.NodeID)
}
func (ctrl Node) GenerateURI(ctx context.Context, r *request.NodeGenerateURI) (interface{}, error) {
@@ -96,15 +95,15 @@ func (ctrl Node) GenerateURI(ctx context.Context, r *request.NodeGenerateURI) (i
}
func (ctrl Node) Pair(ctx context.Context, r *request.NodePair) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.Pair(ctx, r.NodeID)
return api.OK(), ctrl.svcNode.Pair(ctx, r.NodeID)
}
func (ctrl Node) HandshakeConfirm(ctx context.Context, r *request.NodeHandshakeConfirm) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.HandshakeConfirm(ctx, r.NodeID)
return api.OK(), ctrl.svcNode.HandshakeConfirm(ctx, r.NodeID)
}
func (ctrl Node) HandshakeComplete(ctx context.Context, r *request.NodeHandshakeComplete) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.HandshakeComplete(ctx, r.NodeID, r.TokenA)
return api.OK(), ctrl.svcNode.HandshakeComplete(ctx, r.NodeID, r.TokenA)
}
func (ctrl Node) makePayload(ctx context.Context, m *types.Node, err error) (*nodePayload, error) {

5
federation/rest/node_handshake.go
View File

@@ -2,10 +2,9 @@ package rest
import (
"context"
"github.com/titpetric/factory/resputil"
"github.com/cortezaproject/corteza-server/federation/rest/request"
"github.com/cortezaproject/corteza-server/federation/service"
"github.com/cortezaproject/corteza-server/pkg/api"
)
type (
@@ -25,5 +24,5 @@ func (NodeHandshake) New() *NodeHandshake {
}
func (ctrl NodeHandshake) Initialize(ctx context.Context, r *request.NodeHandshakeInitialize) (interface{}, error) {
return resputil.OK(), ctrl.svcNode.HandshakeInit(ctx, r.NodeID, r.PairToken, r.SharedNodeID, r.AuthToken)
return api.OK(), ctrl.svcNode.HandshakeInit(ctx, r.NodeID, r.PairToken, r.SharedNodeID, r.AuthToken)
}

138
federation/rest/request/pair.go
View File

@@ -1,138 +0,0 @@
package request
// This file is auto-generated.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// Definitions file that controls how this file is generated:
//
import (
"encoding/json"
"fmt"
"github.com/cortezaproject/corteza-server/pkg/payload"
"github.com/go-chi/chi"
"io"
"mime/multipart"
"net/http"
"strings"
)
// dummy vars to prevent
// unused imports complain
var (
_ = chi.URLParam
_ = multipart.ErrMessageTooLarge
_ = payload.ParseUint64s
)
type (
// Internal API interface
PairApprovePairing struct {
// RequestID GET parameter
//
// Pair requestID
RequestID uint64 `json:",string"`
}
PairCompletePairing struct {
// Token POST parameter
//
// Auth token of the origin node
Token string
}
)
// NewPairApprovePairing request
func NewPairApprovePairing() *PairApprovePairing {
return &PairApprovePairing{}
}
// Auditable returns all auditable/loggable parameters
func (r PairApprovePairing) Auditable() map[string]interface{} {
return map[string]interface{}{
"requestID": r.RequestID,
}
}
// Auditable returns all auditable/loggable parameters
func (r PairApprovePairing) GetRequestID() uint64 {
return r.RequestID
}
// Fill processes request and fills internal variables
func (r *PairApprovePairing) Fill(req *http.Request) (err error) {
if strings.ToLower(req.Header.Get("content-type")) == "application/json" {
err = json.NewDecoder(req.Body).Decode(r)
switch {
case err == io.EOF:
err = nil
case err != nil:
return fmt.Errorf("error parsing http request body: %w", err)
}
}
{
// GET params
tmp := req.URL.Query()
if val, ok := tmp["requestID"]; ok && len(val) > 0 {
r.RequestID, err = payload.ParseUint64(val[0]), nil
if err != nil {
return err
}
}
}
return err
}
// NewPairCompletePairing request
func NewPairCompletePairing() *PairCompletePairing {
return &PairCompletePairing{}
}
// Auditable returns all auditable/loggable parameters
func (r PairCompletePairing) Auditable() map[string]interface{} {
return map[string]interface{}{
"token": r.Token,
}
}
// Auditable returns all auditable/loggable parameters
func (r PairCompletePairing) GetToken() string {
return r.Token
}
// Fill processes request and fills internal variables
func (r *PairCompletePairing) Fill(req *http.Request) (err error) {
if strings.ToLower(req.Header.Get("content-type")) == "application/json" {
err = json.NewDecoder(req.Body).Decode(r)
switch {
case err == io.EOF:
err = nil
case err != nil:
return fmt.Errorf("error parsing http request body: %w", err)
}
}
{
if err = req.ParseForm(); err != nil {
return err
}
// POST params
if val, ok := req.Form["token"]; ok && len(val) > 0 {
r.Token, err = val[0], nil
if err != nil {
return err
}
}
}
return err
}

773
federation/service/exposed_module_actions.gen.go
View File

File diff suppressed because it is too large Load Diff

691
federation/service/module_mapping_actions.gen.go
View File

@@ -10,13 +10,12 @@ package service
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/cortezaproject/corteza-server/federation/types"
"github.com/cortezaproject/corteza-server/pkg/actionlog"
"github.com/cortezaproject/corteza-server/pkg/errors"
"strings"
"time"
)
type (
@@ -40,19 +39,8 @@ type (
props *moduleMappingActionProps
}
moduleMappingError struct {
timestamp time.Time
error string
resource string
action string
message string
log string
severity actionlog.Severity
wrap error
props *moduleMappingActionProps
}
moduleMappingLogMetaKey struct{}
moduleMappingPropsMetaKey struct{}
)
var (
@@ -107,11 +95,11 @@ func (p *moduleMappingActionProps) setFilter(filter *types.ModuleMappingFilter)
return p
}
// serialize converts moduleMappingActionProps to actionlog.Meta
// Serialize converts moduleMappingActionProps to actionlog.Meta
//
// This function is auto-generated.
//
func (p moduleMappingActionProps) serialize() actionlog.Meta {
func (p moduleMappingActionProps) Serialize() actionlog.Meta {
var (
m = make(actionlog.Meta)
)
@@ -141,7 +129,7 @@ func (p moduleMappingActionProps) serialize() actionlog.Meta {
//
// This function is auto-generated.
//
func (p moduleMappingActionProps) tr(in string, err error) string {
func (p moduleMappingActionProps) Format(in string, err error) string {
var (
pairs = []string{"{err}"}
// first non-empty string
@@ -157,16 +145,6 @@ func (p moduleMappingActionProps) tr(in string, err error) string {
)
if err != nil {
for {
// Unwrap errors
ue := errors.Unwrap(err)
if ue == nil {
break
}
err = ue
}
pairs = append(pairs, err.Error())
} else {
pairs = append(pairs, "nil")
@@ -247,107 +225,16 @@ func (a *moduleMappingAction) String() string {
props = a.props
}
return props.tr(a.log, nil)
return props.Format(a.log, nil)
}
func (e *moduleMappingAction) LoggableAction() *actionlog.Action {
func (e *moduleMappingAction) ToAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Meta: e.props.serialize(),
}
}
// *********************************************************************************************************************
// *********************************************************************************************************************
// Error methods
// String returns loggable description as string
//
// It falls back to message if log is not set
//
// This function is auto-generated.
//
func (e *moduleMappingError) String() string {
var props = &moduleMappingActionProps{}
if e.props != nil {
props = e.props
}
if e.wrap != nil && !strings.Contains(e.log, "{err}") {
// Suffix error log with {err} to ensure
// we log the cause for this error
e.log += ": {err}"
}
return props.tr(e.log, e.wrap)
}
// Error satisfies
//
// This function is auto-generated.
//
func (e *moduleMappingError) Error() string {
var props = &moduleMappingActionProps{}
if e.props != nil {
props = e.props
}
return props.tr(e.message, e.wrap)
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *moduleMappingError) Is(err error) bool {
t, ok := err.(*moduleMappingError)
if !ok {
return false
}
return t.resource == e.resource && t.error == e.error
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *moduleMappingError) IsGeneric() bool {
return e.error == "generic"
}
// Wrap wraps moduleMappingError around another error
//
// This function is auto-generated.
//
func (e *moduleMappingError) Wrap(err error) *moduleMappingError {
e.wrap = err
return e
}
// Unwrap returns wrapped error
//
// This function is auto-generated.
//
func (e *moduleMappingError) Unwrap() error {
return e.wrap
}
func (e *moduleMappingError) LoggableAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Error: e.Error(),
Meta: e.props.serialize(),
Meta: e.props.Serialize(),
}
}
@@ -355,7 +242,7 @@ func (e *moduleMappingError) LoggableAction() *actionlog.Action {
// *********************************************************************************************************************
// Action constructors
// ModuleMappingActionSearch returns "federation:module_mapping.search" error
// ModuleMappingActionSearch returns "federation:module_mapping.search" action
//
// This function is auto-generated.
//
@@ -375,7 +262,7 @@ func ModuleMappingActionSearch(props ...*moduleMappingActionProps) *moduleMappin
return a
}
// ModuleMappingActionLookup returns "federation:module_mapping.lookup" error
// ModuleMappingActionLookup returns "federation:module_mapping.lookup" action
//
// This function is auto-generated.
//
@@ -395,7 +282,7 @@ func ModuleMappingActionLookup(props ...*moduleMappingActionProps) *moduleMappin
return a
}
// ModuleMappingActionCreate returns "federation:module_mapping.create" error
// ModuleMappingActionCreate returns "federation:module_mapping.create" action
//
// This function is auto-generated.
//
@@ -415,7 +302,7 @@ func ModuleMappingActionCreate(props ...*moduleMappingActionProps) *moduleMappin
return a
}
// ModuleMappingActionUpdate returns "federation:module_mapping.update" error
// ModuleMappingActionUpdate returns "federation:module_mapping.update" action
//
// This function is auto-generated.
//
@@ -435,7 +322,7 @@ func ModuleMappingActionUpdate(props ...*moduleMappingActionProps) *moduleMappin
return a
}
// ModuleMappingActionDelete returns "federation:module_mapping.delete" error
// ModuleMappingActionDelete returns "federation:module_mapping.delete" action
//
// This function is auto-generated.
//
@@ -459,334 +346,346 @@ func ModuleMappingActionDelete(props ...*moduleMappingActionProps) *moduleMappin
// *********************************************************************************************************************
// Error constructors
// ModuleMappingErrGeneric returns "federation:module_mapping.generic" audit event as actionlog.Error
// ModuleMappingErrGeneric returns "federation:module_mapping.generic" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrGeneric(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "generic",
action: "error",
message: "failed to complete request due to internal error",
log: "{err}",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrGeneric(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("failed to complete request due to internal error", nil),
errors.Meta("type", "generic"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "{err}"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotFound returns "federation:module_mapping.notFound" audit event as actionlog.Warning
// ModuleMappingErrNotFound returns "federation:module_mapping.notFound" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotFound(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notFound",
action: "error",
message: "module mapping does not exist",
log: "module mapping does not exist",
severity: actionlog.Warning,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotFound(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("module mapping does not exist", nil),
errors.Meta("type", "notFound"),
errors.Meta("resource", "federation:module_mapping"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrComposeModuleNotFound returns "federation:module_mapping.composeModuleNotFound" audit event as actionlog.Warning
// ModuleMappingErrComposeModuleNotFound returns "federation:module_mapping.composeModuleNotFound" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrComposeModuleNotFound(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "composeModuleNotFound",
action: "error",
message: "compose module not found",
log: "compose module not found",
severity: actionlog.Warning,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrComposeModuleNotFound(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("compose module not found", nil),
errors.Meta("type", "composeModuleNotFound"),
errors.Meta("resource", "federation:module_mapping"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrComposeNamespaceNotFound returns "federation:module_mapping.composeNamespaceNotFound" audit event as actionlog.Warning
// ModuleMappingErrComposeNamespaceNotFound returns "federation:module_mapping.composeNamespaceNotFound" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrComposeNamespaceNotFound(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "composeNamespaceNotFound",
action: "error",
message: "compose namespace not found",
log: "compose namespace not found",
severity: actionlog.Warning,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrComposeNamespaceNotFound(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("compose namespace not found", nil),
errors.Meta("type", "composeNamespaceNotFound"),
errors.Meta("resource", "federation:module_mapping"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrFederationModuleNotFound returns "federation:module_mapping.federationModuleNotFound" audit event as actionlog.Warning
// ModuleMappingErrFederationModuleNotFound returns "federation:module_mapping.federationModuleNotFound" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrFederationModuleNotFound(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "federationModuleNotFound",
action: "error",
message: "federation module not found",
log: "federation module not found",
severity: actionlog.Warning,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrFederationModuleNotFound(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("federation module not found", nil),
errors.Meta("type", "federationModuleNotFound"),
errors.Meta("resource", "federation:module_mapping"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrModuleMappingExists returns "federation:module_mapping.moduleMappingExists" audit event as actionlog.Error
// ModuleMappingErrModuleMappingExists returns "federation:module_mapping.moduleMappingExists" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrModuleMappingExists(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "moduleMappingExists",
action: "error",
message: "module mapping already exists",
log: "module mapping already exists",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrModuleMappingExists(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("module mapping already exists", nil),
errors.Meta("type", "moduleMappingExists"),
errors.Meta("resource", "federation:module_mapping"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotAllowedToRead returns "federation:module_mapping.notAllowedToRead" audit event as actionlog.Error
// ModuleMappingErrNotAllowedToRead returns "federation:module_mapping.notAllowedToRead" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotAllowedToRead(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notAllowedToRead",
action: "error",
message: "not allowed to read this module",
log: "could not read module; insufficient permissions",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotAllowedToRead(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to read this module", nil),
errors.Meta("type", "notAllowedToRead"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "could not read module; insufficient permissions"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotAllowedToListModules returns "federation:module_mapping.notAllowedToListModules" audit event as actionlog.Error
// ModuleMappingErrNotAllowedToListModules returns "federation:module_mapping.notAllowedToListModules" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotAllowedToListModules(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notAllowedToListModules",
action: "error",
message: "not allowed to list modules",
log: "could not list modules; insufficient permissions",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotAllowedToListModules(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to list modules", nil),
errors.Meta("type", "notAllowedToListModules"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "could not list modules; insufficient permissions"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotAllowedToCreate returns "federation:module_mapping.notAllowedToCreate" audit event as actionlog.Error
// ModuleMappingErrNotAllowedToCreate returns "federation:module_mapping.notAllowedToCreate" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotAllowedToCreate(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notAllowedToCreate",
action: "error",
message: "not allowed to create modules",
log: "could not create modules; insufficient permissions",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotAllowedToCreate(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to create modules", nil),
errors.Meta("type", "notAllowedToCreate"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "could not create modules; insufficient permissions"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotAllowedToUpdate returns "federation:module_mapping.notAllowedToUpdate" audit event as actionlog.Error
// ModuleMappingErrNotAllowedToUpdate returns "federation:module_mapping.notAllowedToUpdate" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotAllowedToUpdate(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notAllowedToUpdate",
action: "error",
message: "not allowed to update this module",
log: "could not update module; insufficient permissions",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotAllowedToUpdate(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to update this module", nil),
errors.Meta("type", "notAllowedToUpdate"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "could not update module; insufficient permissions"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// ModuleMappingErrNotAllowedToDelete returns "federation:module_mapping.notAllowedToDelete" audit event as actionlog.Error
// ModuleMappingErrNotAllowedToDelete returns "federation:module_mapping.notAllowedToDelete" as *errors.Error
//
//
// This function is auto-generated.
//
func ModuleMappingErrNotAllowedToDelete(props ...*moduleMappingActionProps) *moduleMappingError {
var e = &moduleMappingError{
timestamp: time.Now(),
resource: "federation:module_mapping",
error: "notAllowedToDelete",
action: "error",
message: "not allowed to delete this module",
log: "could not delete module; insufficient permissions",
severity: actionlog.Error,
props: func() *moduleMappingActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func ModuleMappingErrNotAllowedToDelete(mm ...*moduleMappingActionProps) *errors.Error {
var p = &moduleMappingActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to delete this module", nil),
errors.Meta("type", "notAllowedToDelete"),
errors.Meta("resource", "federation:module_mapping"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(moduleMappingLogMetaKey{}, "could not delete module; insufficient permissions"),
errors.Meta(moduleMappingPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// *********************************************************************************************************************
@@ -794,94 +693,42 @@ func ModuleMappingErrNotAllowedToDelete(props ...*moduleMappingActionProps) *mod
// recordAction is a service helper function wraps function that can return error
//
// context is used to enrich audit log entry with current user info, request ID, IP address...
// props are collected action/error properties
// action (optional) fn will be used to construct moduleMappingAction struct from given props (and error)
// err is any error that occurred while action was happening
//
// Action has success and fail (error) state:
// - when recorded without an error (4th param), action is recorded as successful.
// - when an additional error is given (4th param), action is used to wrap
// the additional error
// It will wrap unrecognized/internal errors with generic errors.
//
// This function is auto-generated.
//
func (svc moduleMapping) recordAction(ctx context.Context, props *moduleMappingActionProps, action func(...*moduleMappingActionProps) *moduleMappingAction, err error) error {
var (
ok bool
// Return error
retError *moduleMappingError
// Recorder error
recError *moduleMappingError
)
if err != nil {
if retError, ok = err.(*moduleMappingError); !ok {
// got non-moduleMapping error, wrap it with ModuleMappingErrGeneric
retError = ModuleMappingErrGeneric(props).Wrap(err)
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// we'll use ModuleMappingErrGeneric for recording too
// because it can hold more info
recError = retError
} else if retError != nil {
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// start with copy of return error for recording
// this will be updated with tha root cause as we try and
// unwrap the error
recError = retError
// find the original recError for this error
// for the purpose of logging
var unwrappedError error = retError
for {
if unwrappedError = errors.Unwrap(unwrappedError); unwrappedError == nil {
// nothing wrapped
break
}
// update recError ONLY of wrapped error is of type moduleMappingError
if unwrappedSinkError, ok := unwrappedError.(*moduleMappingError); ok {
recError = unwrappedSinkError
}
}
if retError.props == nil {
// set props on returning error if empty
retError.props = props
}
if recError.props == nil {
// set props on recording error if empty
recError.props = props
}
}
}
if svc.actionlog != nil {
if retError != nil {
// failed action, log error
svc.actionlog.Record(ctx, recError)
} else if action != nil {
// successful
svc.actionlog.Record(ctx, action(props))
}
}
if err == nil {
// retError not an interface and that WILL (!!) cause issues
// with nil check (== nil) when it is not explicitly returned
func (svc moduleMapping) recordAction(ctx context.Context, props *moduleMappingActionProps, actionFn func(...*moduleMappingActionProps) *moduleMappingAction, err error) error {
if svc.actionlog == nil || actionFn == nil {
// action log disabled or no action fn passed, return error as-is
return err
} else if err == nil {
// action completed w/o error, record it
svc.actionlog.Record(ctx, actionFn(props).ToAction())
return nil
}
return retError
a := actionFn(props).ToAction()
// Extracting error information and recording it as action
a.Error = err.Error()
switch c := err.(type) {
case *errors.Error:
m := c.Meta()
a.Error = err.Error()
a.Severity = actionlog.Severity(m.AsInt("severity"))
a.Description = props.Format(m.AsString(moduleMappingLogMetaKey{}), err)
if p, has := m[moduleMappingPropsMetaKey{}]; has {
a.Meta = p.(*moduleMappingActionProps).Serialize()
}
svc.actionlog.Record(ctx, a)
default:
svc.actionlog.Record(ctx, a)
}
// Original error is passed on
return err
}

507
federation/service/node_actions.gen.go
View File

@@ -10,13 +10,12 @@ package service
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/cortezaproject/corteza-server/federation/types"
"github.com/cortezaproject/corteza-server/pkg/actionlog"
"github.com/cortezaproject/corteza-server/pkg/errors"
"strings"
"time"
)
type (
@@ -39,19 +38,8 @@ type (
props *nodeActionProps
}
nodeError struct {
timestamp time.Time
error string
resource string
action string
message string
log string
severity actionlog.Severity
wrap error
props *nodeActionProps
}
nodeLogMetaKey struct{}
nodePropsMetaKey struct{}
)
var (
@@ -95,11 +83,11 @@ func (p *nodeActionProps) setFilter(filter *types.NodeFilter) *nodeActionProps {
return p
}
// serialize converts nodeActionProps to actionlog.Meta
// Serialize converts nodeActionProps to actionlog.Meta
//
// This function is auto-generated.
//
func (p nodeActionProps) serialize() actionlog.Meta {
func (p nodeActionProps) Serialize() actionlog.Meta {
var (
m = make(actionlog.Meta)
)
@@ -123,7 +111,7 @@ func (p nodeActionProps) serialize() actionlog.Meta {
//
// This function is auto-generated.
//
func (p nodeActionProps) tr(in string, err error) string {
func (p nodeActionProps) Format(in string, err error) string {
var (
pairs = []string{"{err}"}
// first non-empty string
@@ -139,16 +127,6 @@ func (p nodeActionProps) tr(in string, err error) string {
)
if err != nil {
for {
// Unwrap errors
ue := errors.Unwrap(err)
if ue == nil {
break
}
err = ue
}
pairs = append(pairs, err.Error())
} else {
pairs = append(pairs, "nil")
@@ -204,107 +182,16 @@ func (a *nodeAction) String() string {
props = a.props
}
return props.tr(a.log, nil)
return props.Format(a.log, nil)
}
func (e *nodeAction) LoggableAction() *actionlog.Action {
func (e *nodeAction) ToAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Meta: e.props.serialize(),
}
}
// *********************************************************************************************************************
// *********************************************************************************************************************
// Error methods
// String returns loggable description as string
//
// It falls back to message if log is not set
//
// This function is auto-generated.
//
func (e *nodeError) String() string {
var props = &nodeActionProps{}
if e.props != nil {
props = e.props
}
if e.wrap != nil && !strings.Contains(e.log, "{err}") {
// Suffix error log with {err} to ensure
// we log the cause for this error
e.log += ": {err}"
}
return props.tr(e.log, e.wrap)
}
// Error satisfies
//
// This function is auto-generated.
//
func (e *nodeError) Error() string {
var props = &nodeActionProps{}
if e.props != nil {
props = e.props
}
return props.tr(e.message, e.wrap)
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *nodeError) Is(err error) bool {
t, ok := err.(*nodeError)
if !ok {
return false
}
return t.resource == e.resource && t.error == e.error
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *nodeError) IsGeneric() bool {
return e.error == "generic"
}
// Wrap wraps nodeError around another error
//
// This function is auto-generated.
//
func (e *nodeError) Wrap(err error) *nodeError {
e.wrap = err
return e
}
// Unwrap returns wrapped error
//
// This function is auto-generated.
//
func (e *nodeError) Unwrap() error {
return e.wrap
}
func (e *nodeError) LoggableAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Error: e.Error(),
Meta: e.props.serialize(),
Meta: e.props.Serialize(),
}
}
@@ -312,7 +199,7 @@ func (e *nodeError) LoggableAction() *actionlog.Action {
// *********************************************************************************************************************
// Action constructors
// NodeActionSearch returns "federation:node.search" error
// NodeActionSearch returns "federation:node.search" action
//
// This function is auto-generated.
//
@@ -332,7 +219,7 @@ func NodeActionSearch(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionLookup returns "federation:node.lookup" error
// NodeActionLookup returns "federation:node.lookup" action
//
// This function is auto-generated.
//
@@ -352,7 +239,7 @@ func NodeActionLookup(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionCreate returns "federation:node.create" error
// NodeActionCreate returns "federation:node.create" action
//
// This function is auto-generated.
//
@@ -372,7 +259,7 @@ func NodeActionCreate(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionCreateFromPairingURI returns "federation:node.createFromPairingURI" error
// NodeActionCreateFromPairingURI returns "federation:node.createFromPairingURI" action
//
// This function is auto-generated.
//
@@ -392,7 +279,7 @@ func NodeActionCreateFromPairingURI(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionRecreateFromPairingURI returns "federation:node.recreateFromPairingURI" error
// NodeActionRecreateFromPairingURI returns "federation:node.recreateFromPairingURI" action
//
// This function is auto-generated.
//
@@ -412,7 +299,7 @@ func NodeActionRecreateFromPairingURI(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionUpdate returns "federation:node.update" error
// NodeActionUpdate returns "federation:node.update" action
//
// This function is auto-generated.
//
@@ -432,7 +319,7 @@ func NodeActionUpdate(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionDelete returns "federation:node.delete" error
// NodeActionDelete returns "federation:node.delete" action
//
// This function is auto-generated.
//
@@ -452,7 +339,7 @@ func NodeActionDelete(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionUndelete returns "federation:node.undelete" error
// NodeActionUndelete returns "federation:node.undelete" action
//
// This function is auto-generated.
//
@@ -472,7 +359,7 @@ func NodeActionUndelete(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionOttRegenerated returns "federation:node.ottRegenerated" error
// NodeActionOttRegenerated returns "federation:node.ottRegenerated" action
//
// This function is auto-generated.
//
@@ -492,7 +379,7 @@ func NodeActionOttRegenerated(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionPair returns "federation:node.pair" error
// NodeActionPair returns "federation:node.pair" action
//
// This function is auto-generated.
//
@@ -512,7 +399,7 @@ func NodeActionPair(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionHandshakeInit returns "federation:node.handshakeInit" error
// NodeActionHandshakeInit returns "federation:node.handshakeInit" action
//
// This function is auto-generated.
//
@@ -532,7 +419,7 @@ func NodeActionHandshakeInit(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionHandshakeConfirm returns "federation:node.handshakeConfirm" error
// NodeActionHandshakeConfirm returns "federation:node.handshakeConfirm" action
//
// This function is auto-generated.
//
@@ -552,7 +439,7 @@ func NodeActionHandshakeConfirm(props ...*nodeActionProps) *nodeAction {
return a
}
// NodeActionHandshakeComplete returns "federation:node.handshakeComplete" error
// NodeActionHandshakeComplete returns "federation:node.handshakeComplete" action
//
// This function is auto-generated.
//
@@ -576,184 +463,186 @@ func NodeActionHandshakeComplete(props ...*nodeActionProps) *nodeAction {
// *********************************************************************************************************************
// Error constructors
// NodeErrGeneric returns "federation:node.generic" audit event as actionlog.Error
// NodeErrGeneric returns "federation:node.generic" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrGeneric(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "generic",
action: "error",
message: "failed to complete request due to internal error",
log: "{err}",
severity: actionlog.Error,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrGeneric(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("failed to complete request due to internal error", nil),
errors.Meta("type", "generic"),
errors.Meta("resource", "federation:node"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(nodeLogMetaKey{}, "{err}"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeErrNotFound returns "federation:node.notFound" audit event as actionlog.Warning
// NodeErrNotFound returns "federation:node.notFound" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrNotFound(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "notFound",
action: "error",
message: "node does not exist",
log: "node does not exist",
severity: actionlog.Warning,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrNotFound(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("node does not exist", nil),
errors.Meta("type", "notFound"),
errors.Meta("resource", "federation:node"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeErrPairingURIInvalid returns "federation:node.pairingURIInvalid" audit event as actionlog.Error
// NodeErrPairingURIInvalid returns "federation:node.pairingURIInvalid" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrPairingURIInvalid(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "pairingURIInvalid",
action: "error",
message: "pairing URI invalid: {err}",
log: "pairing URI invalid: {err}",
severity: actionlog.Error,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrPairingURIInvalid(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("pairing URI invalid: {err}", nil),
errors.Meta("type", "pairingURIInvalid"),
errors.Meta("resource", "federation:node"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeErrPairingURITokenInvalid returns "federation:node.pairingURITokenInvalid" audit event as actionlog.Error
// NodeErrPairingURITokenInvalid returns "federation:node.pairingURITokenInvalid" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrPairingURITokenInvalid(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "pairingURITokenInvalid",
action: "error",
message: "pairing URI with invalid pairing token",
log: "pairing URI with invalid pairing token",
severity: actionlog.Error,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrPairingURITokenInvalid(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("pairing URI with invalid pairing token", nil),
errors.Meta("type", "pairingURITokenInvalid"),
errors.Meta("resource", "federation:node"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeErrPairingURISourceIDInvalid returns "federation:node.pairingURISourceIDInvalid" audit event as actionlog.Error
// NodeErrPairingURISourceIDInvalid returns "federation:node.pairingURISourceIDInvalid" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrPairingURISourceIDInvalid(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "pairingURISourceIDInvalid",
action: "error",
message: "pairing URI without source node ID",
log: "pairing URI without source node ID",
severity: actionlog.Error,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrPairingURISourceIDInvalid(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("pairing URI without source node ID", nil),
errors.Meta("type", "pairingURISourceIDInvalid"),
errors.Meta("resource", "federation:node"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeErrPairingTokenInvalid returns "federation:node.pairingTokenInvalid" audit event as actionlog.Error
// NodeErrPairingTokenInvalid returns "federation:node.pairingTokenInvalid" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeErrPairingTokenInvalid(props ...*nodeActionProps) *nodeError {
var e = &nodeError{
timestamp: time.Now(),
resource: "federation:node",
error: "pairingTokenInvalid",
action: "error",
message: "pairing token invalid",
log: "pairing token invalid",
severity: actionlog.Error,
props: func() *nodeActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeErrPairingTokenInvalid(mm ...*nodeActionProps) *errors.Error {
var p = &nodeActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("pairing token invalid", nil),
errors.Meta("type", "pairingTokenInvalid"),
errors.Meta("resource", "federation:node"),
errors.Meta(nodePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// *********************************************************************************************************************
@@ -761,94 +650,42 @@ func NodeErrPairingTokenInvalid(props ...*nodeActionProps) *nodeError {
// recordAction is a service helper function wraps function that can return error
//
// context is used to enrich audit log entry with current user info, request ID, IP address...
// props are collected action/error properties
// action (optional) fn will be used to construct nodeAction struct from given props (and error)
// err is any error that occurred while action was happening
//
// Action has success and fail (error) state:
// - when recorded without an error (4th param), action is recorded as successful.
// - when an additional error is given (4th param), action is used to wrap
// the additional error
// It will wrap unrecognized/internal errors with generic errors.
//
// This function is auto-generated.
//
func (svc node) recordAction(ctx context.Context, props *nodeActionProps, action func(...*nodeActionProps) *nodeAction, err error) error {
var (
ok bool
// Return error
retError *nodeError
// Recorder error
recError *nodeError
)
if err != nil {
if retError, ok = err.(*nodeError); !ok {
// got non-node error, wrap it with NodeErrGeneric
retError = NodeErrGeneric(props).Wrap(err)
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// we'll use NodeErrGeneric for recording too
// because it can hold more info
recError = retError
} else if retError != nil {
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// start with copy of return error for recording
// this will be updated with tha root cause as we try and
// unwrap the error
recError = retError
// find the original recError for this error
// for the purpose of logging
var unwrappedError error = retError
for {
if unwrappedError = errors.Unwrap(unwrappedError); unwrappedError == nil {
// nothing wrapped
break
}
// update recError ONLY of wrapped error is of type nodeError
if unwrappedSinkError, ok := unwrappedError.(*nodeError); ok {
recError = unwrappedSinkError
}
}
if retError.props == nil {
// set props on returning error if empty
retError.props = props
}
if recError.props == nil {
// set props on recording error if empty
recError.props = props
}
}
}
if svc.actionlog != nil {
if retError != nil {
// failed action, log error
svc.actionlog.Record(ctx, recError)
} else if action != nil {
// successful
svc.actionlog.Record(ctx, action(props))
}
}
if err == nil {
// retError not an interface and that WILL (!!) cause issues
// with nil check (== nil) when it is not explicitly returned
func (svc node) recordAction(ctx context.Context, props *nodeActionProps, actionFn func(...*nodeActionProps) *nodeAction, err error) error {
if svc.actionlog == nil || actionFn == nil {
// action log disabled or no action fn passed, return error as-is
return err
} else if err == nil {
// action completed w/o error, record it
svc.actionlog.Record(ctx, actionFn(props).ToAction())
return nil
}
return retError
a := actionFn(props).ToAction()
// Extracting error information and recording it as action
a.Error = err.Error()
switch c := err.(type) {
case *errors.Error:
m := c.Meta()
a.Error = err.Error()
a.Severity = actionlog.Severity(m.AsInt("severity"))
a.Description = props.Format(m.AsString(nodeLogMetaKey{}), err)
if p, has := m[nodePropsMetaKey{}]; has {
a.Meta = p.(*nodeActionProps).Serialize()
}
svc.actionlog.Record(ctx, a)
default:
svc.actionlog.Record(ctx, a)
}
// Original error is passed on
return err
}

371
federation/service/node_sync_actions.gen.go
View File

@@ -10,13 +10,12 @@ package service
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/cortezaproject/corteza-server/federation/types"
"github.com/cortezaproject/corteza-server/pkg/actionlog"
"github.com/cortezaproject/corteza-server/pkg/errors"
"strings"
"time"
)
type (
@@ -38,19 +37,8 @@ type (
props *nodeSyncActionProps
}
nodeSyncError struct {
timestamp time.Time
error string
resource string
action string
message string
log string
severity actionlog.Severity
wrap error
props *nodeSyncActionProps
}
nodeSyncLogMetaKey struct{}
nodeSyncPropsMetaKey struct{}
)
var (
@@ -83,11 +71,11 @@ func (p *nodeSyncActionProps) setNodeSyncFilter(nodeSyncFilter *types.NodeSyncFi
return p
}
// serialize converts nodeSyncActionProps to actionlog.Meta
// Serialize converts nodeSyncActionProps to actionlog.Meta
//
// This function is auto-generated.
//
func (p nodeSyncActionProps) serialize() actionlog.Meta {
func (p nodeSyncActionProps) Serialize() actionlog.Meta {
var (
m = make(actionlog.Meta)
)
@@ -109,7 +97,7 @@ func (p nodeSyncActionProps) serialize() actionlog.Meta {
//
// This function is auto-generated.
//
func (p nodeSyncActionProps) tr(in string, err error) string {
func (p nodeSyncActionProps) Format(in string, err error) string {
var (
pairs = []string{"{err}"}
// first non-empty string
@@ -125,16 +113,6 @@ func (p nodeSyncActionProps) tr(in string, err error) string {
)
if err != nil {
for {
// Unwrap errors
ue := errors.Unwrap(err)
if ue == nil {
break
}
err = ue
}
pairs = append(pairs, err.Error())
} else {
pairs = append(pairs, "nil")
@@ -187,107 +165,16 @@ func (a *nodeSyncAction) String() string {
props = a.props
}
return props.tr(a.log, nil)
return props.Format(a.log, nil)
}
func (e *nodeSyncAction) LoggableAction() *actionlog.Action {
func (e *nodeSyncAction) ToAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Meta: e.props.serialize(),
}
}
// *********************************************************************************************************************
// *********************************************************************************************************************
// Error methods
// String returns loggable description as string
//
// It falls back to message if log is not set
//
// This function is auto-generated.
//
func (e *nodeSyncError) String() string {
var props = &nodeSyncActionProps{}
if e.props != nil {
props = e.props
}
if e.wrap != nil && !strings.Contains(e.log, "{err}") {
// Suffix error log with {err} to ensure
// we log the cause for this error
e.log += ": {err}"
}
return props.tr(e.log, e.wrap)
}
// Error satisfies
//
// This function is auto-generated.
//
func (e *nodeSyncError) Error() string {
var props = &nodeSyncActionProps{}
if e.props != nil {
props = e.props
}
return props.tr(e.message, e.wrap)
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *nodeSyncError) Is(err error) bool {
t, ok := err.(*nodeSyncError)
if !ok {
return false
}
return t.resource == e.resource && t.error == e.error
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *nodeSyncError) IsGeneric() bool {
return e.error == "generic"
}
// Wrap wraps nodeSyncError around another error
//
// This function is auto-generated.
//
func (e *nodeSyncError) Wrap(err error) *nodeSyncError {
e.wrap = err
return e
}
// Unwrap returns wrapped error
//
// This function is auto-generated.
//
func (e *nodeSyncError) Unwrap() error {
return e.wrap
}
func (e *nodeSyncError) LoggableAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Error: e.Error(),
Meta: e.props.serialize(),
Meta: e.props.Serialize(),
}
}
@@ -295,7 +182,7 @@ func (e *nodeSyncError) LoggableAction() *actionlog.Action {
// *********************************************************************************************************************
// Action constructors
// NodeSyncActionLookup returns "federation:node_sync.lookup" error
// NodeSyncActionLookup returns "federation:node_sync.lookup" action
//
// This function is auto-generated.
//
@@ -315,7 +202,7 @@ func NodeSyncActionLookup(props ...*nodeSyncActionProps) *nodeSyncAction {
return a
}
// NodeSyncActionCreate returns "federation:node_sync.create" error
// NodeSyncActionCreate returns "federation:node_sync.create" action
//
// This function is auto-generated.
//
@@ -339,94 +226,96 @@ func NodeSyncActionCreate(props ...*nodeSyncActionProps) *nodeSyncAction {
// *********************************************************************************************************************
// Error constructors
// NodeSyncErrGeneric returns "federation:node_sync.generic" audit event as actionlog.Error
// NodeSyncErrGeneric returns "federation:node_sync.generic" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeSyncErrGeneric(props ...*nodeSyncActionProps) *nodeSyncError {
var e = &nodeSyncError{
timestamp: time.Now(),
resource: "federation:node_sync",
error: "generic",
action: "error",
message: "failed to complete request due to internal error",
log: "{err}",
severity: actionlog.Error,
props: func() *nodeSyncActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeSyncErrGeneric(mm ...*nodeSyncActionProps) *errors.Error {
var p = &nodeSyncActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("failed to complete request due to internal error", nil),
errors.Meta("type", "generic"),
errors.Meta("resource", "federation:node_sync"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(nodeSyncLogMetaKey{}, "{err}"),
errors.Meta(nodeSyncPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeSyncErrNotFound returns "federation:node_sync.notFound" audit event as actionlog.Warning
// NodeSyncErrNotFound returns "federation:node_sync.notFound" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeSyncErrNotFound(props ...*nodeSyncActionProps) *nodeSyncError {
var e = &nodeSyncError{
timestamp: time.Now(),
resource: "federation:node_sync",
error: "notFound",
action: "error",
message: "node_sync does not exist",
log: "node_sync does not exist",
severity: actionlog.Warning,
props: func() *nodeSyncActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeSyncErrNotFound(mm ...*nodeSyncActionProps) *errors.Error {
var p = &nodeSyncActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("node_sync does not exist", nil),
errors.Meta("type", "notFound"),
errors.Meta("resource", "federation:node_sync"),
errors.Meta(nodeSyncPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// NodeSyncErrNodeNotFound returns "federation:node_sync.nodeNotFound" audit event as actionlog.Warning
// NodeSyncErrNodeNotFound returns "federation:node_sync.nodeNotFound" as *errors.Error
//
//
// This function is auto-generated.
//
func NodeSyncErrNodeNotFound(props ...*nodeSyncActionProps) *nodeSyncError {
var e = &nodeSyncError{
timestamp: time.Now(),
resource: "federation:node_sync",
error: "nodeNotFound",
action: "error",
message: "node does not exist",
log: "node does not exist",
severity: actionlog.Warning,
props: func() *nodeSyncActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func NodeSyncErrNodeNotFound(mm ...*nodeSyncActionProps) *errors.Error {
var p = &nodeSyncActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("node does not exist", nil),
errors.Meta("type", "nodeNotFound"),
errors.Meta("resource", "federation:node_sync"),
errors.Meta(nodeSyncPropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// *********************************************************************************************************************
@@ -434,94 +323,42 @@ func NodeSyncErrNodeNotFound(props ...*nodeSyncActionProps) *nodeSyncError {
// recordAction is a service helper function wraps function that can return error
//
// context is used to enrich audit log entry with current user info, request ID, IP address...
// props are collected action/error properties
// action (optional) fn will be used to construct nodeSyncAction struct from given props (and error)
// err is any error that occurred while action was happening
//
// Action has success and fail (error) state:
// - when recorded without an error (4th param), action is recorded as successful.
// - when an additional error is given (4th param), action is used to wrap
// the additional error
// It will wrap unrecognized/internal errors with generic errors.
//
// This function is auto-generated.
//
func (svc nodeSync) recordAction(ctx context.Context, props *nodeSyncActionProps, action func(...*nodeSyncActionProps) *nodeSyncAction, err error) error {
var (
ok bool
// Return error
retError *nodeSyncError
// Recorder error
recError *nodeSyncError
)
if err != nil {
if retError, ok = err.(*nodeSyncError); !ok {
// got non-nodeSync error, wrap it with NodeSyncErrGeneric
retError = NodeSyncErrGeneric(props).Wrap(err)
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// we'll use NodeSyncErrGeneric for recording too
// because it can hold more info
recError = retError
} else if retError != nil {
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// start with copy of return error for recording
// this will be updated with tha root cause as we try and
// unwrap the error
recError = retError
// find the original recError for this error
// for the purpose of logging
var unwrappedError error = retError
for {
if unwrappedError = errors.Unwrap(unwrappedError); unwrappedError == nil {
// nothing wrapped
break
}
// update recError ONLY of wrapped error is of type nodeSyncError
if unwrappedSinkError, ok := unwrappedError.(*nodeSyncError); ok {
recError = unwrappedSinkError
}
}
if retError.props == nil {
// set props on returning error if empty
retError.props = props
}
if recError.props == nil {
// set props on recording error if empty
recError.props = props
}
}
}
if svc.actionlog != nil {
if retError != nil {
// failed action, log error
svc.actionlog.Record(ctx, recError)
} else if action != nil {
// successful
svc.actionlog.Record(ctx, action(props))
}
}
if err == nil {
// retError not an interface and that WILL (!!) cause issues
// with nil check (== nil) when it is not explicitly returned
func (svc nodeSync) recordAction(ctx context.Context, props *nodeSyncActionProps, actionFn func(...*nodeSyncActionProps) *nodeSyncAction, err error) error {
if svc.actionlog == nil || actionFn == nil {
// action log disabled or no action fn passed, return error as-is
return err
} else if err == nil {
// action completed w/o error, record it
svc.actionlog.Record(ctx, actionFn(props).ToAction())
return nil
}
return retError
a := actionFn(props).ToAction()
// Extracting error information and recording it as action
a.Error = err.Error()
switch c := err.(type) {
case *errors.Error:
m := c.Meta()
a.Error = err.Error()
a.Severity = actionlog.Severity(m.AsInt("severity"))
a.Description = props.Format(m.AsString(nodeSyncLogMetaKey{}), err)
if p, has := m[nodeSyncPropsMetaKey{}]; has {
a.Meta = p.(*nodeSyncActionProps).Serialize()
}
svc.actionlog.Record(ctx, a)
default:
svc.actionlog.Record(ctx, a)
}
// Original error is passed on
return err
}

697
federation/service/shared_module_actions.gen.go
View File

@@ -10,13 +10,12 @@ package service
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/cortezaproject/corteza-server/federation/types"
"github.com/cortezaproject/corteza-server/pkg/actionlog"
"github.com/cortezaproject/corteza-server/pkg/errors"
"strings"
"time"
)
type (
@@ -40,19 +39,8 @@ type (
props *sharedModuleActionProps
}
sharedModuleError struct {
timestamp time.Time
error string
resource string
action string
message string
log string
severity actionlog.Severity
wrap error
props *sharedModuleActionProps
}
sharedModuleLogMetaKey struct{}
sharedModulePropsMetaKey struct{}
)
var (
@@ -107,11 +95,11 @@ func (p *sharedModuleActionProps) setNode(node *types.Node) *sharedModuleActionP
return p
}
// serialize converts sharedModuleActionProps to actionlog.Meta
// Serialize converts sharedModuleActionProps to actionlog.Meta
//
// This function is auto-generated.
//
func (p sharedModuleActionProps) serialize() actionlog.Meta {
func (p sharedModuleActionProps) Serialize() actionlog.Meta {
var (
m = make(actionlog.Meta)
)
@@ -139,7 +127,7 @@ func (p sharedModuleActionProps) serialize() actionlog.Meta {
//
// This function is auto-generated.
//
func (p sharedModuleActionProps) tr(in string, err error) string {
func (p sharedModuleActionProps) Format(in string, err error) string {
var (
pairs = []string{"{err}"}
// first non-empty string
@@ -155,16 +143,6 @@ func (p sharedModuleActionProps) tr(in string, err error) string {
)
if err != nil {
for {
// Unwrap errors
ue := errors.Unwrap(err)
if ue == nil {
break
}
err = ue
}
pairs = append(pairs, err.Error())
} else {
pairs = append(pairs, "nil")
@@ -241,107 +219,16 @@ func (a *sharedModuleAction) String() string {
props = a.props
}
return props.tr(a.log, nil)
return props.Format(a.log, nil)
}
func (e *sharedModuleAction) LoggableAction() *actionlog.Action {
func (e *sharedModuleAction) ToAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Meta: e.props.serialize(),
}
}
// *********************************************************************************************************************
// *********************************************************************************************************************
// Error methods
// String returns loggable description as string
//
// It falls back to message if log is not set
//
// This function is auto-generated.
//
func (e *sharedModuleError) String() string {
var props = &sharedModuleActionProps{}
if e.props != nil {
props = e.props
}
if e.wrap != nil && !strings.Contains(e.log, "{err}") {
// Suffix error log with {err} to ensure
// we log the cause for this error
e.log += ": {err}"
}
return props.tr(e.log, e.wrap)
}
// Error satisfies
//
// This function is auto-generated.
//
func (e *sharedModuleError) Error() string {
var props = &sharedModuleActionProps{}
if e.props != nil {
props = e.props
}
return props.tr(e.message, e.wrap)
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *sharedModuleError) Is(err error) bool {
t, ok := err.(*sharedModuleError)
if !ok {
return false
}
return t.resource == e.resource && t.error == e.error
}
// Is fn for error equality check
//
// This function is auto-generated.
//
func (e *sharedModuleError) IsGeneric() bool {
return e.error == "generic"
}
// Wrap wraps sharedModuleError around another error
//
// This function is auto-generated.
//
func (e *sharedModuleError) Wrap(err error) *sharedModuleError {
e.wrap = err
return e
}
// Unwrap returns wrapped error
//
// This function is auto-generated.
//
func (e *sharedModuleError) Unwrap() error {
return e.wrap
}
func (e *sharedModuleError) LoggableAction() *actionlog.Action {
return &actionlog.Action{
Timestamp: e.timestamp,
Resource: e.resource,
Action: e.action,
Severity: e.severity,
Description: e.String(),
Error: e.Error(),
Meta: e.props.serialize(),
Meta: e.props.Serialize(),
}
}
@@ -349,7 +236,7 @@ func (e *sharedModuleError) LoggableAction() *actionlog.Action {
// *********************************************************************************************************************
// Action constructors
// SharedModuleActionSearch returns "federation:shared_module.search" error
// SharedModuleActionSearch returns "federation:shared_module.search" action
//
// This function is auto-generated.
//
@@ -369,7 +256,7 @@ func SharedModuleActionSearch(props ...*sharedModuleActionProps) *sharedModuleAc
return a
}
// SharedModuleActionLookup returns "federation:shared_module.lookup" error
// SharedModuleActionLookup returns "federation:shared_module.lookup" action
//
// This function is auto-generated.
//
@@ -389,7 +276,7 @@ func SharedModuleActionLookup(props ...*sharedModuleActionProps) *sharedModuleAc
return a
}
// SharedModuleActionCreate returns "federation:shared_module.create" error
// SharedModuleActionCreate returns "federation:shared_module.create" action
//
// This function is auto-generated.
//
@@ -409,7 +296,7 @@ func SharedModuleActionCreate(props ...*sharedModuleActionProps) *sharedModuleAc
return a
}
// SharedModuleActionUpdate returns "federation:shared_module.update" error
// SharedModuleActionUpdate returns "federation:shared_module.update" action
//
// This function is auto-generated.
//
@@ -429,7 +316,7 @@ func SharedModuleActionUpdate(props ...*sharedModuleActionProps) *sharedModuleAc
return a
}
// SharedModuleActionDelete returns "federation:shared_module.delete" error
// SharedModuleActionDelete returns "federation:shared_module.delete" action
//
// This function is auto-generated.
//
@@ -449,7 +336,7 @@ func SharedModuleActionDelete(props ...*sharedModuleActionProps) *sharedModuleAc
return a
}
// SharedModuleActionUndelete returns "federation:shared_module.undelete" error
// SharedModuleActionUndelete returns "federation:shared_module.undelete" action
//
// This function is auto-generated.
//
@@ -473,334 +360,350 @@ func SharedModuleActionUndelete(props ...*sharedModuleActionProps) *sharedModule
// *********************************************************************************************************************
// Error constructors
// SharedModuleErrGeneric returns "federation:shared_module.generic" audit event as actionlog.Error
// SharedModuleErrGeneric returns "federation:shared_module.generic" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrGeneric(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "generic",
action: "error",
message: "failed to complete request due to internal error",
log: "{err}",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrGeneric(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("failed to complete request due to internal error", nil),
errors.Meta("type", "generic"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "{err}"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotFound returns "federation:shared_module.notFound" audit event as actionlog.Warning
// SharedModuleErrNotFound returns "federation:shared_module.notFound" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotFound(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notFound",
action: "error",
message: "module does not exist",
log: "module does not exist",
severity: actionlog.Warning,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotFound(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("module does not exist", nil),
errors.Meta("type", "notFound"),
errors.Meta("resource", "federation:shared_module"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrInvalidID returns "federation:shared_module.invalidID" audit event as actionlog.Warning
// SharedModuleErrInvalidID returns "federation:shared_module.invalidID" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrInvalidID(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "invalidID",
action: "error",
message: "invalid ID",
log: "invalid ID",
severity: actionlog.Warning,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrInvalidID(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("invalid ID", nil),
errors.Meta("type", "invalidID"),
errors.Meta("resource", "federation:shared_module"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrStaleData returns "federation:shared_module.staleData" audit event as actionlog.Warning
// SharedModuleErrStaleData returns "federation:shared_module.staleData" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrStaleData(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "staleData",
action: "error",
message: "stale data",
log: "stale data",
severity: actionlog.Warning,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrStaleData(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("stale data", nil),
errors.Meta("type", "staleData"),
errors.Meta("resource", "federation:shared_module"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotUnique returns "federation:shared_module.notUnique" audit event as actionlog.Warning
// SharedModuleErrNotUnique returns "federation:shared_module.notUnique" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotUnique(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notUnique",
action: "error",
message: "node not unique",
log: "used duplicate node TODO",
severity: actionlog.Warning,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotUnique(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("node not unique", nil),
errors.Meta("type", "notUnique"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "used duplicate node TODO"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToRead returns "federation:shared_module.notAllowedToRead" audit event as actionlog.Error
// SharedModuleErrNotAllowedToRead returns "federation:shared_module.notAllowedToRead" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToRead(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToRead",
action: "error",
message: "not allowed to read this module",
log: "could not read {module}; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToRead(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to read this module", nil),
errors.Meta("type", "notAllowedToRead"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not read {module}; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToListModules returns "federation:shared_module.notAllowedToListModules" audit event as actionlog.Error
// SharedModuleErrNotAllowedToListModules returns "federation:shared_module.notAllowedToListModules" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToListModules(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToListModules",
action: "error",
message: "not allowed to list modules",
log: "could not list modules; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToListModules(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to list modules", nil),
errors.Meta("type", "notAllowedToListModules"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not list modules; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToCreate returns "federation:shared_module.notAllowedToCreate" audit event as actionlog.Error
// SharedModuleErrNotAllowedToCreate returns "federation:shared_module.notAllowedToCreate" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToCreate(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToCreate",
action: "error",
message: "not allowed to create modules",
log: "could not create modules; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToCreate(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to create modules", nil),
errors.Meta("type", "notAllowedToCreate"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not create modules; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToUpdate returns "federation:shared_module.notAllowedToUpdate" audit event as actionlog.Error
// SharedModuleErrNotAllowedToUpdate returns "federation:shared_module.notAllowedToUpdate" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToUpdate(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToUpdate",
action: "error",
message: "not allowed to update this module",
log: "could not update {module}; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToUpdate(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to update this module", nil),
errors.Meta("type", "notAllowedToUpdate"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not update {module}; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToDelete returns "federation:shared_module.notAllowedToDelete" audit event as actionlog.Error
// SharedModuleErrNotAllowedToDelete returns "federation:shared_module.notAllowedToDelete" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToDelete(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToDelete",
action: "error",
message: "not allowed to delete this module",
log: "could not delete {module}; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToDelete(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to delete this module", nil),
errors.Meta("type", "notAllowedToDelete"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not delete {module}; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// SharedModuleErrNotAllowedToUndelete returns "federation:shared_module.notAllowedToUndelete" audit event as actionlog.Error
// SharedModuleErrNotAllowedToUndelete returns "federation:shared_module.notAllowedToUndelete" as *errors.Error
//
//
// This function is auto-generated.
//
func SharedModuleErrNotAllowedToUndelete(props ...*sharedModuleActionProps) *sharedModuleError {
var e = &sharedModuleError{
timestamp: time.Now(),
resource: "federation:shared_module",
error: "notAllowedToUndelete",
action: "error",
message: "not allowed to undelete this module",
log: "could not undelete {module}; insufficient permissions",
severity: actionlog.Error,
props: func() *sharedModuleActionProps {
if len(props) > 0 {
return props[0]
}
return nil
}(),
func SharedModuleErrNotAllowedToUndelete(mm ...*sharedModuleActionProps) *errors.Error {
var p = &sharedModuleActionProps{}
if len(mm) > 0 {
p = mm[0]
}
if len(props) > 0 {
e.props = props[0]
var e = errors.New(
errors.KindInternal,
p.Format("not allowed to undelete this module", nil),
errors.Meta("type", "notAllowedToUndelete"),
errors.Meta("resource", "federation:shared_module"),
// action log entry; no formatting, it will be applied inside recordAction fn.
errors.Meta(sharedModuleLogMetaKey{}, "could not undelete {module}; insufficient permissions"),
errors.Meta(sharedModulePropsMetaKey{}, p),
errors.StackSkip(1),
)
if len(mm) > 0 {
}
return e
}
// *********************************************************************************************************************
@@ -808,94 +711,42 @@ func SharedModuleErrNotAllowedToUndelete(props ...*sharedModuleActionProps) *sha
// recordAction is a service helper function wraps function that can return error
//
// context is used to enrich audit log entry with current user info, request ID, IP address...
// props are collected action/error properties
// action (optional) fn will be used to construct sharedModuleAction struct from given props (and error)
// err is any error that occurred while action was happening
//
// Action has success and fail (error) state:
// - when recorded without an error (4th param), action is recorded as successful.
// - when an additional error is given (4th param), action is used to wrap
// the additional error
// It will wrap unrecognized/internal errors with generic errors.
//
// This function is auto-generated.
//
func (svc sharedModule) recordAction(ctx context.Context, props *sharedModuleActionProps, action func(...*sharedModuleActionProps) *sharedModuleAction, err error) error {
var (
ok bool
// Return error
retError *sharedModuleError
// Recorder error
recError *sharedModuleError
)
if err != nil {
if retError, ok = err.(*sharedModuleError); !ok {
// got non-sharedModule error, wrap it with SharedModuleErrGeneric
retError = SharedModuleErrGeneric(props).Wrap(err)
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// we'll use SharedModuleErrGeneric for recording too
// because it can hold more info
recError = retError
} else if retError != nil {
if action != nil {
// copy action to returning and recording error
retError.action = action().action
}
// start with copy of return error for recording
// this will be updated with tha root cause as we try and
// unwrap the error
recError = retError
// find the original recError for this error
// for the purpose of logging
var unwrappedError error = retError
for {
if unwrappedError = errors.Unwrap(unwrappedError); unwrappedError == nil {
// nothing wrapped
break
}
// update recError ONLY of wrapped error is of type sharedModuleError
if unwrappedSinkError, ok := unwrappedError.(*sharedModuleError); ok {
recError = unwrappedSinkError
}
}
if retError.props == nil {
// set props on returning error if empty
retError.props = props
}
if recError.props == nil {
// set props on recording error if empty
recError.props = props
}
}
}
if svc.actionlog != nil {
if retError != nil {
// failed action, log error
svc.actionlog.Record(ctx, recError)
} else if action != nil {
// successful
svc.actionlog.Record(ctx, action(props))
}
}
if err == nil {
// retError not an interface and that WILL (!!) cause issues
// with nil check (== nil) when it is not explicitly returned
func (svc sharedModule) recordAction(ctx context.Context, props *sharedModuleActionProps, actionFn func(...*sharedModuleActionProps) *sharedModuleAction, err error) error {
if svc.actionlog == nil || actionFn == nil {
// action log disabled or no action fn passed, return error as-is
return err
} else if err == nil {
// action completed w/o error, record it
svc.actionlog.Record(ctx, actionFn(props).ToAction())
return nil
}
return retError
a := actionFn(props).ToAction()
// Extracting error information and recording it as action
a.Error = err.Error()
switch c := err.(type) {
case *errors.Error:
m := c.Meta()
a.Error = err.Error()
a.Severity = actionlog.Severity(m.AsInt("severity"))
a.Description = props.Format(m.AsString(sharedModuleLogMetaKey{}), err)
if p, has := m[sharedModulePropsMetaKey{}]; has {
a.Meta = p.(*sharedModuleActionProps).Serialize()
}
svc.actionlog.Record(ctx, a)
default:
svc.actionlog.Record(ctx, a)
}
// Original error is passed on
return err
}