Skip to content
Snippets Groups Projects
Commit 7704aee3 authored by Valera Shaitorov's avatar Valera Shaitorov :alien:
Browse files

Добавлены Spaces middlewares

parent 0c8c31ca
No related branches found
No related tags found
No related merge requests found
package service
import (
"context"
"git.perx.ru/perxis/perxis-go/pkg/cache"
service "git.perx.ru/perxis/perxis-go/pkg/spaces"
)
func orgKey(orgID string) string { return "org-" + orgID }
func CachingMiddleware(cache *cache.Cache) Middleware {
return func(next service.Spaces) service.Spaces {
m := &cachingMiddleware{
cache: cache,
next: next,
}
return m
}
}
type cachingMiddleware struct {
cache *cache.Cache
next service.Spaces
}
func (m cachingMiddleware) Create(ctx context.Context, space *service.Space) (sp *service.Space, err error) {
sp, err = m.next.Create(ctx, space)
if err == nil {
m.cache.Remove(orgKey(sp.OrgID))
}
return sp, err
}
func (m cachingMiddleware) Get(ctx context.Context, spaceId string) (sp *service.Space, err error) {
value, e := m.cache.Get(spaceId)
if e == nil {
return value.(*service.Space), err
}
sp, err = m.next.Get(ctx, spaceId)
if err == nil {
m.cache.Set(spaceId, sp)
}
return sp, err
}
func (m cachingMiddleware) List(ctx context.Context, orgId string) (spaces []*service.Space, err error) {
value, e := m.cache.Get(orgKey(orgId))
if e == nil {
return value.([]*service.Space), err
}
spaces, err = m.next.List(ctx, orgId)
if err == nil {
m.cache.Set(orgKey(orgId), spaces)
for _, s := range spaces {
m.cache.Set(s.ID, s)
}
}
return spaces, err
}
func (m cachingMiddleware) Update(ctx context.Context, space *service.Space) (err error) {
err = m.next.Update(ctx, space)
if err == nil {
value, e := m.cache.Get(space.ID)
if e == nil {
space := value.(*service.Space)
m.cache.Remove(orgKey(space.OrgID))
}
m.cache.Remove(space.ID)
}
return err
}
func (m cachingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *service.Config) (err error) {
err = m.next.UpdateConfig(ctx, spaceId, config)
if err == nil {
value, e := m.cache.Get(spaceId)
if e == nil {
space := value.(*service.Space)
m.cache.Remove(orgKey(space.OrgID))
}
m.cache.Remove(spaceId)
}
return err
}
func (m cachingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
err = m.next.Delete(ctx, spaceId)
if err == nil {
value, e := m.cache.Get(spaceId)
if e == nil {
space := value.(*service.Space)
m.cache.Remove(orgKey(space.OrgID))
}
m.cache.Remove(spaceId)
}
return err
}
package service
import (
"context"
"testing"
"time"
"git.perx.ru/perxis/perxis-go/pkg/cache"
"git.perx.ru/perxis/perxis-go/pkg/errors"
"git.perx.ru/perxis/perxis-go/pkg/spaces"
spmocks "git.perx.ru/perxis/perxis-go/pkg/spaces/mocks"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
)
func TestRolesCache(t *testing.T) {
const (
spaceID = "spaceID"
orgID = "orgID"
size = 5
ttl = 20 * time.Millisecond
)
errNotFound := errors.NotFound(errors.New("not found"))
ctx := context.Background()
t.Run("Get from cache", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
v1, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
v2, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.Same(t, v1, v2, "Ожидается при повторном запросе получение объекта из кэша.")
sp.AssertExpectations(t)
})
t.Run("List from cache", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
vl1, err := svc.List(ctx, orgID)
require.NoError(t, err)
vl2, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Same(t, vl1[0], vl2[0], "Ожидается при повторном запросе получение объектов из кэша.")
sp.AssertExpectations(t)
})
t.Run("Invalidate cache", func(t *testing.T) {
t.Run("After Update", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
v1, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
v2, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.Same(t, v1, v2, "Ожидается при повторном запросе получение объекта из кэша.")
vl1, err := svc.List(ctx, orgID)
require.NoError(t, err)
vl2, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Same(t, vl1[0], vl2[0], "Ожидается при повторном запросе получение объектов из кэша.")
sp.On("Update", mock.Anything, mock.Anything).Return(nil).Once()
err = svc.Update(ctx, &spaces.Space{ID: spaceID, OrgID: orgID, Name: "SpaceUPD"})
require.NoError(t, err)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "SpaceUPD"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "SpaceUPD"}}, nil).Once()
v3, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.NotSame(t, v2, v3, "Ожидается что кеш объекта был удален после обновления объекта.")
vl3, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.NotSame(t, vl2[0], vl3[0], "Ожидается что кеш объектов был удален после обновления объекта.")
sp.AssertExpectations(t)
})
t.Run("After UpdateConfig", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
v1, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
v2, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.Same(t, v1, v2, "Ожидается при повторном запросе получение объекта из кэша.")
vl1, err := svc.List(ctx, orgID)
require.NoError(t, err)
vl2, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Same(t, vl1[0], vl2[0], "Ожидается при повторном запросе получение объектов из кэша.")
sp.On("UpdateConfig", mock.Anything, spaceID, mock.Anything).Return(nil).Once()
err = svc.UpdateConfig(ctx, spaceID, &spaces.Config{Features: []string{"feature"}})
require.NoError(t, err)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "SpaceUPD", Config: &spaces.Config{Features: []string{"feature"}}}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "SpaceUPD", Config: &spaces.Config{Features: []string{"feature"}}}}, nil).Once()
v3, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.NotSame(t, v2, v3, "Ожидается что кеш объекта был удален после обновления объекта.")
vl3, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.NotSame(t, vl2[0], vl3[0], "Ожидается что кеш объектов был удален после обновления объекта.")
sp.AssertExpectations(t)
})
t.Run("After Delete", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
v1, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
v2, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.Same(t, v1, v2, "Ожидается при повторном запросе получение объекта из кэша.")
vl1, err := svc.List(ctx, orgID)
require.NoError(t, err)
vl2, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Same(t, vl1[0], vl2[0], "Ожидается при повторном запросе получение объектов из кэша.")
sp.On("Delete", mock.Anything, spaceID).Return(nil).Once()
err = svc.Delete(ctx, spaceID)
require.NoError(t, err)
sp.On("Get", mock.Anything, spaceID).Return(nil, errNotFound).Once()
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{}, nil).Once()
_, err = svc.Get(ctx, spaceID)
require.Error(t, err)
assert.EqualError(t, err, "not found", "Ожидается что после удаления объекта кеш был удален и получена ошибка от сервиса.")
vl3, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Len(t, vl3, 0, "Ожидается что после удаления кеш объектов был удален.")
sp.AssertExpectations(t)
})
t.Run("After Create", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}}, nil).Once()
vl1, err := svc.List(ctx, orgID)
require.NoError(t, err)
vl2, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.Same(t, vl1[0], vl2[0], "Ожидается при повторном запросе получение объектов из кэша.")
sp.On("Create", mock.Anything, mock.Anything).Return(&spaces.Space{ID: "spaceID2", OrgID: orgID, Name: "Space2"}, nil).Once()
_, err = svc.Create(ctx, &spaces.Space{ID: "spaceID2", OrgID: orgID, Name: "Space2"})
require.NoError(t, err)
sp.On("List", mock.Anything, orgID).Return([]*spaces.Space{{ID: spaceID, OrgID: orgID, Name: "Space"}, {ID: "spaceID2", OrgID: orgID, Name: "Space2"}}, nil).Once()
vl3, err := svc.List(ctx, orgID)
require.NoError(t, err)
assert.NotSame(t, vl2[0], vl3[0], "Ожидается что кеш объектов был удален после создания нового объекта.")
sp.AssertExpectations(t)
})
t.Run("After TTL expired", func(t *testing.T) {
sp := &spmocks.Spaces{}
svc := CachingMiddleware(cache.NewCache(size, ttl))(sp)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
v1, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
v2, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.Same(t, v1, v2, "Ожидается при повторном запросе получение объекта из кэша.")
time.Sleep(2 * ttl)
sp.On("Get", mock.Anything, spaceID).Return(&spaces.Space{ID: spaceID, OrgID: orgID, Name: "Space"}, nil).Once()
v3, err := svc.Get(ctx, spaceID)
require.NoError(t, err)
assert.NotSame(t, v2, v3, "Ожидается удаление объекта из кэша по истечению ttl.")
sp.AssertExpectations(t)
})
})
}
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../assets/templates/middleware/error_log
// gowrap: http://github.com/hexdigest/gowrap
package service
//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/error_log -o error_logging_middleware.go -l ""
import (
"context"
"git.perx.ru/perxis/perxis-go/pkg/spaces"
"go.uber.org/zap"
)
// errorLoggingMiddleware implements spaces.Spaces that is instrumented with logging
type errorLoggingMiddleware struct {
logger *zap.Logger
next spaces.Spaces
}
// ErrorLoggingMiddleware instruments an implementation of the spaces.Spaces with simple logging
func ErrorLoggingMiddleware(logger *zap.Logger) Middleware {
return func(next spaces.Spaces) spaces.Spaces {
return &errorLoggingMiddleware{
next: next,
logger: logger,
}
}
}
func (m *errorLoggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.Create(ctx, space)
}
func (m *errorLoggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.Delete(ctx, spaceId)
}
func (m *errorLoggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.Get(ctx, spaceId)
}
func (m *errorLoggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.List(ctx, orgId)
}
func (m *errorLoggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.Update(ctx, space)
}
func (m *errorLoggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
logger := m.logger
defer func() {
if err != nil {
logger.Warn("response error", zap.Error(err))
}
}()
return m.next.UpdateConfig(ctx, spaceId, config)
}
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../assets/templates/middleware/access_log
// gowrap: http://github.com/hexdigest/gowrap
package service
//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/access_log -o logging_middleware.go -l ""
import (
"context"
"fmt"
"time"
"git.perx.ru/perxis/perxis-go/pkg/auth"
"git.perx.ru/perxis/perxis-go/pkg/spaces"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
// loggingMiddleware implements spaces.Spaces that is instrumented with logging
type loggingMiddleware struct {
logger *zap.Logger
next spaces.Spaces
}
// LoggingMiddleware instruments an implementation of the spaces.Spaces with simple logging
func LoggingMiddleware(logger *zap.Logger) Middleware {
return func(next spaces.Spaces) spaces.Spaces {
return &loggingMiddleware{
next: next,
logger: logger,
}
}
}
func (m *loggingMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"space": space} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Create.Request", fields...)
created, err = m.next.Create(ctx, space)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"created": created,
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Create.Response", fields...)
return created, err
}
func (m *loggingMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Delete.Request", fields...)
err = m.next.Delete(ctx, spaceId)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Delete.Response", fields...)
return err
}
func (m *loggingMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Get.Request", fields...)
space, err = m.next.Get(ctx, spaceId)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"space": space,
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Get.Response", fields...)
return space, err
}
func (m *loggingMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"orgId": orgId} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("List.Request", fields...)
spaces, err = m.next.List(ctx, orgId)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"spaces": spaces,
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("List.Response", fields...)
return spaces, err
}
func (m *loggingMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"space": space} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Update.Request", fields...)
err = m.next.Update(ctx, space)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("Update.Response", fields...)
return err
}
func (m *loggingMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
begin := time.Now()
var fields []zapcore.Field
for k, v := range map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"config": config} {
if k == "ctx" {
fields = append(fields, zap.String("principal", fmt.Sprint(auth.GetPrincipal(ctx))))
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("UpdateConfig.Request", fields...)
err = m.next.UpdateConfig(ctx, spaceId, config)
fields = []zapcore.Field{
zap.Duration("time", time.Since(begin)),
zap.Error(err),
}
for k, v := range map[string]interface{}{
"err": err} {
if k == "err" {
continue
}
fields = append(fields, zap.Reflect(k, v))
}
m.logger.Debug("UpdateConfig.Response", fields...)
return err
}
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../assets/templates/middleware/middleware
// gowrap: http://github.com/hexdigest/gowrap
package service
//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/middleware -o middleware.go -l ""
import (
"git.perx.ru/perxis/perxis-go/pkg/spaces"
"go.uber.org/zap"
)
type Middleware func(spaces.Spaces) spaces.Spaces
func WithLog(s spaces.Spaces, logger *zap.Logger, log_access bool) spaces.Spaces {
if logger == nil {
logger = zap.NewNop()
}
logger = logger.Named("Spaces")
s = ErrorLoggingMiddleware(logger)(s)
if log_access {
s = LoggingMiddleware(logger)(s)
}
s = RecoveringMiddleware(logger)(s)
return s
}
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../assets/templates/middleware/recovery
// gowrap: http://github.com/hexdigest/gowrap
package service
//go:generate gowrap gen -p git.perx.ru/perxis/perxis-go/pkg/spaces -i Spaces -t ../../../assets/templates/middleware/recovery -o recovering_middleware.go -l ""
import (
"context"
"fmt"
"git.perx.ru/perxis/perxis-go/pkg/spaces"
"go.uber.org/zap"
)
// recoveringMiddleware implements spaces.Spaces that is instrumented with logging
type recoveringMiddleware struct {
logger *zap.Logger
next spaces.Spaces
}
// RecoveringMiddleware instruments an implementation of the spaces.Spaces with simple logging
func RecoveringMiddleware(logger *zap.Logger) Middleware {
return func(next spaces.Spaces) spaces.Spaces {
return &recoveringMiddleware{
next: next,
logger: logger,
}
}
}
func (m *recoveringMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.Create(ctx, space)
}
func (m *recoveringMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.Delete(ctx, spaceId)
}
func (m *recoveringMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.Get(ctx, spaceId)
}
func (m *recoveringMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.List(ctx, orgId)
}
func (m *recoveringMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.Update(ctx, space)
}
func (m *recoveringMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
logger := m.logger
defer func() {
if r := recover(); r != nil {
logger.Error("panic", zap.Error(fmt.Errorf("%v", r)))
err = fmt.Errorf("%v", r)
}
}()
return m.next.UpdateConfig(ctx, spaceId, config)
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment