diff --git a/apiserver/grpcserver/discover/v1/client_access.go b/apiserver/grpcserver/discover/v1/client_access.go index d2a42d6ce..2281771ad 100644 --- a/apiserver/grpcserver/discover/v1/client_access.go +++ b/apiserver/grpcserver/discover/v1/client_access.go @@ -131,18 +131,6 @@ func (g *DiscoverServer) Discover(server apiservice.PolarisGRPC_DiscoverServer) var out *apiservice.DiscoverResponse var action string startTime := commontime.CurrentMillisecond() - defer func() { - plugin.GetStatis().ReportDiscoverCall(metrics.ClientDiscoverMetric{ - Action: action, - ClientIP: utils.ParseClientAddress(ctx), - Namespace: in.GetService().GetNamespace().GetValue(), - Resource: in.GetType().String() + ":" + in.GetService().GetName().GetValue(), - Timestamp: startTime, - CostTime: commontime.CurrentMillisecond() - startTime, - Revision: out.GetService().GetRevision().GetValue(), - Success: out.GetCode().GetValue() > uint32(apimodel.Code_DataNoChange), - }) - }() // 兼容。如果请求中带了token，优先使用该token if in.GetService().GetToken().GetValue() != "" { @@ -173,6 +161,16 @@ func (g *DiscoverServer) Discover(server apiservice.PolarisGRPC_DiscoverServer) } err = server.Send(out) + plugin.GetStatis().ReportDiscoverCall(metrics.ClientDiscoverMetric{ + Action: action, + ClientIP: utils.ParseClientAddress(ctx), + Namespace: in.GetService().GetNamespace().GetValue(), + Resource: in.GetType().String() + ":" + in.GetService().GetName().GetValue(), + Timestamp: startTime, + CostTime: commontime.CurrentMillisecond() - startTime, + Revision: out.GetService().GetRevision().GetValue(), + Success: out.GetCode().GetValue() > uint32(apimodel.Code_DataNoChange), + }) if err != nil { return err } diff --git a/cache/api/tools.go b/cache/api/tools.go new file mode 100644 index 000000000..2aa0f86f0 --- /dev/null +++ b/cache/api/tools.go @@ -0,0 +1,53 @@ +/** + * Tencent is pleased to support the open source community by making Polaris available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package api + +import "time" + +func NewExpireEntry[T any](t T, maxAlive time.Duration) *ExpireEntry[T] { + return &ExpireEntry[T]{ + data: t, + maxAlive: maxAlive, + } +} + +func EmptyExpireEntry[T any](t T, maxAlive time.Duration) *ExpireEntry[T] { + return &ExpireEntry[T]{ + empty: true, + maxAlive: maxAlive, + } +} + +type ExpireEntry[T any] struct { + empty bool + data T + lastAccess time.Time + maxAlive time.Duration +} + +func (e *ExpireEntry[T]) Get() T { + if e.empty { + return e.data + } + e.lastAccess = time.Now() + return e.data +} + +func (e *ExpireEntry[T]) IsExpire() bool { + return time.Since(e.lastAccess) > e.maxAlive +} diff --git a/cache/api/types.go b/cache/api/types.go index 506d63aac..a29a5e291 100644 --- a/cache/api/types.go +++ b/cache/api/types.go @@ -266,8 +266,10 @@ type ( GetAliasFor(name string, namespace string) *model.Service // GetRevisionWorker . GetRevisionWorker() ServiceRevisionWorker - // GetVisibleServicesInOtherNamespace get same service in other namespace and it's visible - GetVisibleServicesInOtherNamespace(name string, namespace string) []*model.Service + // GetVisibleSameNameServices get same service in other namespace and it's visible + GetVisibleSameNameServices(name string, namespace string) []*model.Service + // GetVisibleServices get all services in other namespace and it's visible + GetVisibleServices(ctx context.Context, namespace string) []*model.Service } // ServiceRevisionWorker @@ -881,36 +883,3 @@ type ( HitGrayRule(name string, labels map[string]string) bool } ) - -func NewExpireEntry[T any](t T, maxAlive time.Duration) *ExpireEntry[T] { - return &ExpireEntry[T]{ - data: t, - maxAlive: maxAlive, - } -} - -func EmptyExpireEntry[T any](t T, maxAlive time.Duration) *ExpireEntry[T] { - return &ExpireEntry[T]{ - empty: true, - maxAlive: maxAlive, - } -} - -type ExpireEntry[T any] struct { - empty bool - data T - lastAccess time.Time - maxAlive time.Duration -} - -func (e *ExpireEntry[T]) Get() T { - if e.empty { - return e.data - } - e.lastAccess = time.Now() - return e.data -} - -func (e *ExpireEntry[T]) IsExpire() bool { - return time.Since(e.lastAccess) > e.maxAlive -} diff --git a/cache/mock/cache_mock.go b/cache/mock/cache_mock.go index 6a8441864..fe4264711 100644 --- a/cache/mock/cache_mock.go +++ b/cache/mock/cache_mock.go @@ -6,9 +6,6 @@ package mock import ( context "context" - reflect "reflect" - time "time" - gomock "github.com/golang/mock/gomock" api "github.com/polarismesh/polaris/cache/api" model "github.com/polarismesh/polaris/common/model" @@ -18,74 +15,76 @@ import ( security "github.com/polarismesh/specification/source/go/api/v1/security" service_manage "github.com/polarismesh/specification/source/go/api/v1/service_manage" traffic_manage "github.com/polarismesh/specification/source/go/api/v1/traffic_manage" + reflect "reflect" + time "time" ) -// MockCache is a mock of Cache interface. +// MockCache is a mock of Cache interface type MockCache struct { ctrl *gomock.Controller recorder *MockCacheMockRecorder } -// MockCacheMockRecorder is the mock recorder for MockCache. +// MockCacheMockRecorder is the mock recorder for MockCache type MockCacheMockRecorder struct { mock *MockCache } -// NewMockCache creates a new mock instance. +// NewMockCache creates a new mock instance func NewMockCache(ctrl *gomock.Controller) *MockCache { mock := &MockCache{ctrl: ctrl} mock.recorder = &MockCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockCache) EXPECT() *MockCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockCache) Clear() error { +// Initialize mocks base method +func (m *MockCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockCache) Close() error { +// Update mocks base method +func (m *MockCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCache)(nil).Update)) } -// Initialize mocks base method. -func (m *MockCache) Initialize(c map[string]interface{}) error { +// Clear mocks base method +func (m *MockCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Clear") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCache)(nil).Clear)) } -// Name mocks base method. +// Name mocks base method func (m *MockCache) Name() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Name") @@ -93,383 +92,411 @@ func (m *MockCache) Name() string { return ret0 } -// Name indicates an expected call of Name. +// Name indicates an expected call of Name func (mr *MockCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCache)(nil).Name)) } -// Update mocks base method. -func (m *MockCache) Update() error { +// Close mocks base method +func (m *MockCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockCacheMockRecorder) Update() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCache)(nil).Close)) } -// MockCacheManager is a mock of CacheManager interface. +// MockCacheManager is a mock of CacheManager interface type MockCacheManager struct { ctrl *gomock.Controller recorder *MockCacheManagerMockRecorder } -// MockCacheManagerMockRecorder is the mock recorder for MockCacheManager. +// MockCacheManagerMockRecorder is the mock recorder for MockCacheManager type MockCacheManagerMockRecorder struct { mock *MockCacheManager } -// NewMockCacheManager creates a new mock instance. +// NewMockCacheManager creates a new mock instance func NewMockCacheManager(ctrl *gomock.Controller) *MockCacheManager { mock := &MockCacheManager{ctrl: ctrl} mock.recorder = &MockCacheManagerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockCacheManager) EXPECT() *MockCacheManagerMockRecorder { return m.recorder } -// AuthStrategy mocks base method. -func (m *MockCacheManager) AuthStrategy() api.StrategyCache { +// GetUpdateCacheInterval mocks base method +func (m *MockCacheManager) GetUpdateCacheInterval() time.Duration { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthStrategy") - ret0, _ := ret[0].(api.StrategyCache) + ret := m.ctrl.Call(m, "GetUpdateCacheInterval") + ret0, _ := ret[0].(time.Duration) return ret0 } -// AuthStrategy indicates an expected call of AuthStrategy. -func (mr *MockCacheManagerMockRecorder) AuthStrategy() *gomock.Call { +// GetUpdateCacheInterval indicates an expected call of GetUpdateCacheInterval +func (mr *MockCacheManagerMockRecorder) GetUpdateCacheInterval() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthStrategy", reflect.TypeOf((*MockCacheManager)(nil).AuthStrategy)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateCacheInterval", reflect.TypeOf((*MockCacheManager)(nil).GetUpdateCacheInterval)) } -// CL5 mocks base method. -func (m *MockCacheManager) CL5() api.L5Cache { +// GetReportInterval mocks base method +func (m *MockCacheManager) GetReportInterval() time.Duration { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CL5") - ret0, _ := ret[0].(api.L5Cache) + ret := m.ctrl.Call(m, "GetReportInterval") + ret0, _ := ret[0].(time.Duration) return ret0 } -// CL5 indicates an expected call of CL5. -func (mr *MockCacheManagerMockRecorder) CL5() *gomock.Call { +// GetReportInterval indicates an expected call of GetReportInterval +func (mr *MockCacheManagerMockRecorder) GetReportInterval() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CL5", reflect.TypeOf((*MockCacheManager)(nil).CL5)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReportInterval", reflect.TypeOf((*MockCacheManager)(nil).GetReportInterval)) } -// CircuitBreaker mocks base method. -func (m *MockCacheManager) CircuitBreaker() api.CircuitBreakerCache { +// GetCacher mocks base method +func (m *MockCacheManager) GetCacher(cacheIndex api.CacheIndex) api.Cache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CircuitBreaker") - ret0, _ := ret[0].(api.CircuitBreakerCache) + ret := m.ctrl.Call(m, "GetCacher", cacheIndex) + ret0, _ := ret[0].(api.Cache) return ret0 } -// CircuitBreaker indicates an expected call of CircuitBreaker. -func (mr *MockCacheManagerMockRecorder) CircuitBreaker() *gomock.Call { +// GetCacher indicates an expected call of GetCacher +func (mr *MockCacheManagerMockRecorder) GetCacher(cacheIndex interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CircuitBreaker", reflect.TypeOf((*MockCacheManager)(nil).CircuitBreaker)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacher", reflect.TypeOf((*MockCacheManager)(nil).GetCacher), cacheIndex) } -// Client mocks base method. -func (m *MockCacheManager) Client() api.ClientCache { +// RegisterCacher mocks base method +func (m *MockCacheManager) RegisterCacher(cacheIndex api.CacheIndex, item api.Cache) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Client") - ret0, _ := ret[0].(api.ClientCache) - return ret0 + m.ctrl.Call(m, "RegisterCacher", cacheIndex, item) } -// Client indicates an expected call of Client. -func (mr *MockCacheManagerMockRecorder) Client() *gomock.Call { +// RegisterCacher indicates an expected call of RegisterCacher +func (mr *MockCacheManagerMockRecorder) RegisterCacher(cacheIndex, item interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockCacheManager)(nil).Client)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCacher", reflect.TypeOf((*MockCacheManager)(nil).RegisterCacher), cacheIndex, item) } -// ConfigFile mocks base method. -func (m *MockCacheManager) ConfigFile() api.ConfigFileCache { +// OpenResourceCache mocks base method +func (m *MockCacheManager) OpenResourceCache(entries ...api.ConfigEntry) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigFile") - ret0, _ := ret[0].(api.ConfigFileCache) + varargs := []interface{}{} + for _, a := range entries { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "OpenResourceCache", varargs...) + ret0, _ := ret[0].(error) return ret0 } -// ConfigFile indicates an expected call of ConfigFile. -func (mr *MockCacheManagerMockRecorder) ConfigFile() *gomock.Call { +// OpenResourceCache indicates an expected call of OpenResourceCache +func (mr *MockCacheManagerMockRecorder) OpenResourceCache(entries ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigFile", reflect.TypeOf((*MockCacheManager)(nil).ConfigFile)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenResourceCache", reflect.TypeOf((*MockCacheManager)(nil).OpenResourceCache), entries...) } -// ConfigGroup mocks base method. -func (m *MockCacheManager) ConfigGroup() api.ConfigGroupCache { +// Service mocks base method +func (m *MockCacheManager) Service() api.ServiceCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfigGroup") - ret0, _ := ret[0].(api.ConfigGroupCache) + ret := m.ctrl.Call(m, "Service") + ret0, _ := ret[0].(api.ServiceCache) return ret0 } -// ConfigGroup indicates an expected call of ConfigGroup. -func (mr *MockCacheManagerMockRecorder) ConfigGroup() *gomock.Call { +// Service indicates an expected call of Service +func (mr *MockCacheManagerMockRecorder) Service() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGroup", reflect.TypeOf((*MockCacheManager)(nil).ConfigGroup)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Service", reflect.TypeOf((*MockCacheManager)(nil).Service)) } -// FaultDetector mocks base method. -func (m *MockCacheManager) FaultDetector() api.FaultDetectCache { +// Instance mocks base method +func (m *MockCacheManager) Instance() api.InstanceCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FaultDetector") - ret0, _ := ret[0].(api.FaultDetectCache) + ret := m.ctrl.Call(m, "Instance") + ret0, _ := ret[0].(api.InstanceCache) return ret0 } -// FaultDetector indicates an expected call of FaultDetector. -func (mr *MockCacheManagerMockRecorder) FaultDetector() *gomock.Call { +// Instance indicates an expected call of Instance +func (mr *MockCacheManagerMockRecorder) Instance() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FaultDetector", reflect.TypeOf((*MockCacheManager)(nil).FaultDetector)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Instance", reflect.TypeOf((*MockCacheManager)(nil).Instance)) } -// GetCacher mocks base method. -func (m *MockCacheManager) GetCacher(cacheIndex api.CacheIndex) api.Cache { +// RoutingConfig mocks base method +func (m *MockCacheManager) RoutingConfig() api.RoutingConfigCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCacher", cacheIndex) - ret0, _ := ret[0].(api.Cache) + ret := m.ctrl.Call(m, "RoutingConfig") + ret0, _ := ret[0].(api.RoutingConfigCache) return ret0 } -// GetCacher indicates an expected call of GetCacher. -func (mr *MockCacheManagerMockRecorder) GetCacher(cacheIndex interface{}) *gomock.Call { +// RoutingConfig indicates an expected call of RoutingConfig +func (mr *MockCacheManagerMockRecorder) RoutingConfig() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacher", reflect.TypeOf((*MockCacheManager)(nil).GetCacher), cacheIndex) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoutingConfig", reflect.TypeOf((*MockCacheManager)(nil).RoutingConfig)) } -// GetReportInterval mocks base method. -func (m *MockCacheManager) GetReportInterval() time.Duration { +// CL5 mocks base method +func (m *MockCacheManager) CL5() api.L5Cache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetReportInterval") - ret0, _ := ret[0].(time.Duration) + ret := m.ctrl.Call(m, "CL5") + ret0, _ := ret[0].(api.L5Cache) return ret0 } -// GetReportInterval indicates an expected call of GetReportInterval. -func (mr *MockCacheManagerMockRecorder) GetReportInterval() *gomock.Call { +// CL5 indicates an expected call of CL5 +func (mr *MockCacheManagerMockRecorder) CL5() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReportInterval", reflect.TypeOf((*MockCacheManager)(nil).GetReportInterval)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CL5", reflect.TypeOf((*MockCacheManager)(nil).CL5)) } -// GetUpdateCacheInterval mocks base method. -func (m *MockCacheManager) GetUpdateCacheInterval() time.Duration { +// RateLimit mocks base method +func (m *MockCacheManager) RateLimit() api.RateLimitCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetUpdateCacheInterval") - ret0, _ := ret[0].(time.Duration) + ret := m.ctrl.Call(m, "RateLimit") + ret0, _ := ret[0].(api.RateLimitCache) return ret0 } -// GetUpdateCacheInterval indicates an expected call of GetUpdateCacheInterval. -func (mr *MockCacheManagerMockRecorder) GetUpdateCacheInterval() *gomock.Call { +// RateLimit indicates an expected call of RateLimit +func (mr *MockCacheManagerMockRecorder) RateLimit() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateCacheInterval", reflect.TypeOf((*MockCacheManager)(nil).GetUpdateCacheInterval)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RateLimit", reflect.TypeOf((*MockCacheManager)(nil).RateLimit)) } -// Gray mocks base method. -func (m *MockCacheManager) Gray() api.GrayCache { +// CircuitBreaker mocks base method +func (m *MockCacheManager) CircuitBreaker() api.CircuitBreakerCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Gray") - ret0, _ := ret[0].(api.GrayCache) + ret := m.ctrl.Call(m, "CircuitBreaker") + ret0, _ := ret[0].(api.CircuitBreakerCache) return ret0 } -// Gray indicates an expected call of Gray. -func (mr *MockCacheManagerMockRecorder) Gray() *gomock.Call { +// CircuitBreaker indicates an expected call of CircuitBreaker +func (mr *MockCacheManagerMockRecorder) CircuitBreaker() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gray", reflect.TypeOf((*MockCacheManager)(nil).Gray)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CircuitBreaker", reflect.TypeOf((*MockCacheManager)(nil).CircuitBreaker)) } -// Instance mocks base method. -func (m *MockCacheManager) Instance() api.InstanceCache { +// FaultDetector mocks base method +func (m *MockCacheManager) FaultDetector() api.FaultDetectCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Instance") - ret0, _ := ret[0].(api.InstanceCache) + ret := m.ctrl.Call(m, "FaultDetector") + ret0, _ := ret[0].(api.FaultDetectCache) return ret0 } -// Instance indicates an expected call of Instance. -func (mr *MockCacheManagerMockRecorder) Instance() *gomock.Call { +// FaultDetector indicates an expected call of FaultDetector +func (mr *MockCacheManagerMockRecorder) FaultDetector() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Instance", reflect.TypeOf((*MockCacheManager)(nil).Instance)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FaultDetector", reflect.TypeOf((*MockCacheManager)(nil).FaultDetector)) } -// LaneRule mocks base method. -func (m *MockCacheManager) LaneRule() api.LaneCache { +// ServiceContract mocks base method +func (m *MockCacheManager) ServiceContract() api.ServiceContractCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LaneRule") - ret0, _ := ret[0].(api.LaneCache) + ret := m.ctrl.Call(m, "ServiceContract") + ret0, _ := ret[0].(api.ServiceContractCache) return ret0 } -// LaneRule indicates an expected call of LaneRule. -func (mr *MockCacheManagerMockRecorder) LaneRule() *gomock.Call { +// ServiceContract indicates an expected call of ServiceContract +func (mr *MockCacheManagerMockRecorder) ServiceContract() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaneRule", reflect.TypeOf((*MockCacheManager)(nil).LaneRule)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceContract", reflect.TypeOf((*MockCacheManager)(nil).ServiceContract)) } -// Namespace mocks base method. -func (m *MockCacheManager) Namespace() api.NamespaceCache { +// LaneRule mocks base method +func (m *MockCacheManager) LaneRule() api.LaneCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Namespace") - ret0, _ := ret[0].(api.NamespaceCache) + ret := m.ctrl.Call(m, "LaneRule") + ret0, _ := ret[0].(api.LaneCache) return ret0 } -// Namespace indicates an expected call of Namespace. -func (mr *MockCacheManagerMockRecorder) Namespace() *gomock.Call { +// LaneRule indicates an expected call of LaneRule +func (mr *MockCacheManagerMockRecorder) LaneRule() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespace", reflect.TypeOf((*MockCacheManager)(nil).Namespace)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LaneRule", reflect.TypeOf((*MockCacheManager)(nil).LaneRule)) } -// OpenResourceCache mocks base method. -func (m *MockCacheManager) OpenResourceCache(entries ...api.ConfigEntry) error { +// User mocks base method +func (m *MockCacheManager) User() api.UserCache { m.ctrl.T.Helper() - varargs := []interface{}{} - for _, a := range entries { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "OpenResourceCache", varargs...) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "User") + ret0, _ := ret[0].(api.UserCache) return ret0 } -// OpenResourceCache indicates an expected call of OpenResourceCache. -func (mr *MockCacheManagerMockRecorder) OpenResourceCache(entries ...interface{}) *gomock.Call { +// User indicates an expected call of User +func (mr *MockCacheManagerMockRecorder) User() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenResourceCache", reflect.TypeOf((*MockCacheManager)(nil).OpenResourceCache), entries...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "User", reflect.TypeOf((*MockCacheManager)(nil).User)) } -// RateLimit mocks base method. -func (m *MockCacheManager) RateLimit() api.RateLimitCache { +// AuthStrategy mocks base method +func (m *MockCacheManager) AuthStrategy() api.StrategyCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RateLimit") - ret0, _ := ret[0].(api.RateLimitCache) + ret := m.ctrl.Call(m, "AuthStrategy") + ret0, _ := ret[0].(api.StrategyCache) return ret0 } -// RateLimit indicates an expected call of RateLimit. -func (mr *MockCacheManagerMockRecorder) RateLimit() *gomock.Call { +// AuthStrategy indicates an expected call of AuthStrategy +func (mr *MockCacheManagerMockRecorder) AuthStrategy() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RateLimit", reflect.TypeOf((*MockCacheManager)(nil).RateLimit)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthStrategy", reflect.TypeOf((*MockCacheManager)(nil).AuthStrategy)) } -// RegisterCacher mocks base method. -func (m *MockCacheManager) RegisterCacher(cacheIndex api.CacheIndex, item api.Cache) { +// Namespace mocks base method +func (m *MockCacheManager) Namespace() api.NamespaceCache { m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterCacher", cacheIndex, item) + ret := m.ctrl.Call(m, "Namespace") + ret0, _ := ret[0].(api.NamespaceCache) + return ret0 } -// RegisterCacher indicates an expected call of RegisterCacher. -func (mr *MockCacheManagerMockRecorder) RegisterCacher(cacheIndex, item interface{}) *gomock.Call { +// Namespace indicates an expected call of Namespace +func (mr *MockCacheManagerMockRecorder) Namespace() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCacher", reflect.TypeOf((*MockCacheManager)(nil).RegisterCacher), cacheIndex, item) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespace", reflect.TypeOf((*MockCacheManager)(nil).Namespace)) } -// Role mocks base method. -func (m *MockCacheManager) Role() api.RoleCache { +// Client mocks base method +func (m *MockCacheManager) Client() api.ClientCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Role") - ret0, _ := ret[0].(api.RoleCache) + ret := m.ctrl.Call(m, "Client") + ret0, _ := ret[0].(api.ClientCache) return ret0 } -// Role indicates an expected call of Role. -func (mr *MockCacheManagerMockRecorder) Role() *gomock.Call { +// Client indicates an expected call of Client +func (mr *MockCacheManagerMockRecorder) Client() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Role", reflect.TypeOf((*MockCacheManager)(nil).Role)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockCacheManager)(nil).Client)) } -// RoutingConfig mocks base method. -func (m *MockCacheManager) RoutingConfig() api.RoutingConfigCache { +// ConfigFile mocks base method +func (m *MockCacheManager) ConfigFile() api.ConfigFileCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RoutingConfig") - ret0, _ := ret[0].(api.RoutingConfigCache) + ret := m.ctrl.Call(m, "ConfigFile") + ret0, _ := ret[0].(api.ConfigFileCache) return ret0 } -// RoutingConfig indicates an expected call of RoutingConfig. -func (mr *MockCacheManagerMockRecorder) RoutingConfig() *gomock.Call { +// ConfigFile indicates an expected call of ConfigFile +func (mr *MockCacheManagerMockRecorder) ConfigFile() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoutingConfig", reflect.TypeOf((*MockCacheManager)(nil).RoutingConfig)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigFile", reflect.TypeOf((*MockCacheManager)(nil).ConfigFile)) } -// Service mocks base method. -func (m *MockCacheManager) Service() api.ServiceCache { +// ConfigGroup mocks base method +func (m *MockCacheManager) ConfigGroup() api.ConfigGroupCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Service") - ret0, _ := ret[0].(api.ServiceCache) + ret := m.ctrl.Call(m, "ConfigGroup") + ret0, _ := ret[0].(api.ConfigGroupCache) return ret0 } -// Service indicates an expected call of Service. -func (mr *MockCacheManagerMockRecorder) Service() *gomock.Call { +// ConfigGroup indicates an expected call of ConfigGroup +func (mr *MockCacheManagerMockRecorder) ConfigGroup() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Service", reflect.TypeOf((*MockCacheManager)(nil).Service)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGroup", reflect.TypeOf((*MockCacheManager)(nil).ConfigGroup)) } -// ServiceContract mocks base method. -func (m *MockCacheManager) ServiceContract() api.ServiceContractCache { +// Gray mocks base method +func (m *MockCacheManager) Gray() api.GrayCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ServiceContract") - ret0, _ := ret[0].(api.ServiceContractCache) + ret := m.ctrl.Call(m, "Gray") + ret0, _ := ret[0].(api.GrayCache) return ret0 } -// ServiceContract indicates an expected call of ServiceContract. -func (mr *MockCacheManagerMockRecorder) ServiceContract() *gomock.Call { +// Gray indicates an expected call of Gray +func (mr *MockCacheManagerMockRecorder) Gray() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceContract", reflect.TypeOf((*MockCacheManager)(nil).ServiceContract)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gray", reflect.TypeOf((*MockCacheManager)(nil).Gray)) } -// User mocks base method. -func (m *MockCacheManager) User() api.UserCache { +// Role mocks base method +func (m *MockCacheManager) Role() api.RoleCache { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "User") - ret0, _ := ret[0].(api.UserCache) + ret := m.ctrl.Call(m, "Role") + ret0, _ := ret[0].(api.RoleCache) return ret0 } -// User indicates an expected call of User. -func (mr *MockCacheManagerMockRecorder) User() *gomock.Call { +// Role indicates an expected call of Role +func (mr *MockCacheManagerMockRecorder) Role() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "User", reflect.TypeOf((*MockCacheManager)(nil).User)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Role", reflect.TypeOf((*MockCacheManager)(nil).Role)) } -// MockNamespaceCache is a mock of NamespaceCache interface. +// MockNamespaceCache is a mock of NamespaceCache interface type MockNamespaceCache struct { ctrl *gomock.Controller recorder *MockNamespaceCacheMockRecorder } -// MockNamespaceCacheMockRecorder is the mock recorder for MockNamespaceCache. +// MockNamespaceCacheMockRecorder is the mock recorder for MockNamespaceCache type MockNamespaceCacheMockRecorder struct { mock *MockNamespaceCache } -// NewMockNamespaceCache creates a new mock instance. +// NewMockNamespaceCache creates a new mock instance func NewMockNamespaceCache(ctrl *gomock.Controller) *MockNamespaceCache { mock := &MockNamespaceCache{ctrl: ctrl} mock.recorder = &MockNamespaceCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockNamespaceCache) EXPECT() *MockNamespaceCacheMockRecorder { return m.recorder } -// Clear mocks base method. +// Initialize mocks base method +func (m *MockNamespaceCache) Initialize(c map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialize indicates an expected call of Initialize +func (mr *MockNamespaceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockNamespaceCache)(nil).Initialize), c) +} + +// Update mocks base method +func (m *MockNamespaceCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (mr *MockNamespaceCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNamespaceCache)(nil).Update)) +} + +// Clear mocks base method func (m *MockNamespaceCache) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -477,13 +504,27 @@ func (m *MockNamespaceCache) Clear() error { return ret0 } -// Clear indicates an expected call of Clear. +// Clear indicates an expected call of Clear func (mr *MockNamespaceCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockNamespaceCache)(nil).Clear)) } -// Close mocks base method. +// Name mocks base method +func (m *MockNamespaceCache) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name +func (mr *MockNamespaceCacheMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNamespaceCache)(nil).Name)) +} + +// Close mocks base method func (m *MockNamespaceCache) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -491,13 +532,13 @@ func (m *MockNamespaceCache) Close() error { return ret0 } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockNamespaceCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockNamespaceCache)(nil).Close)) } -// GetNamespace mocks base method. +// GetNamespace mocks base method func (m *MockNamespaceCache) GetNamespace(id string) *model.Namespace { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNamespace", id) @@ -505,27 +546,13 @@ func (m *MockNamespaceCache) GetNamespace(id string) *model.Namespace { return ret0 } -// GetNamespace indicates an expected call of GetNamespace. +// GetNamespace indicates an expected call of GetNamespace func (mr *MockNamespaceCacheMockRecorder) GetNamespace(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespace), id) } -// GetNamespaceList mocks base method. -func (m *MockNamespaceCache) GetNamespaceList() []*model.Namespace { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNamespaceList") - ret0, _ := ret[0].([]*model.Namespace) - return ret0 -} - -// GetNamespaceList indicates an expected call of GetNamespaceList. -func (mr *MockNamespaceCacheMockRecorder) GetNamespaceList() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceList", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespaceList)) -} - -// GetNamespacesByName mocks base method. +// GetNamespacesByName mocks base method func (m *MockNamespaceCache) GetNamespacesByName(names []string) []*model.Namespace { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNamespacesByName", names) @@ -533,55 +560,41 @@ func (m *MockNamespaceCache) GetNamespacesByName(names []string) []*model.Namesp return ret0 } -// GetNamespacesByName indicates an expected call of GetNamespacesByName. +// GetNamespacesByName indicates an expected call of GetNamespacesByName func (mr *MockNamespaceCacheMockRecorder) GetNamespacesByName(names interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespacesByName", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespacesByName), names) -} - -// GetVisibleNamespaces mocks base method. -func (m *MockNamespaceCache) GetVisibleNamespaces(namespace string) []*model.Namespace { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVisibleNamespaces", namespace) - ret0, _ := ret[0].([]*model.Namespace) - return ret0 -} - -// GetVisibleNamespaces indicates an expected call of GetVisibleNamespaces. -func (mr *MockNamespaceCacheMockRecorder) GetVisibleNamespaces(namespace interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibleNamespaces", reflect.TypeOf((*MockNamespaceCache)(nil).GetVisibleNamespaces), namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespacesByName", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespacesByName), names) } -// Initialize mocks base method. -func (m *MockNamespaceCache) Initialize(c map[string]interface{}) error { +// GetNamespaceList mocks base method +func (m *MockNamespaceCache) GetNamespaceList() []*model.Namespace { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetNamespaceList") + ret0, _ := ret[0].([]*model.Namespace) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockNamespaceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// GetNamespaceList indicates an expected call of GetNamespaceList +func (mr *MockNamespaceCacheMockRecorder) GetNamespaceList() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockNamespaceCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceList", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespaceList)) } -// Name mocks base method. -func (m *MockNamespaceCache) Name() string { +// GetVisibleNamespaces mocks base method +func (m *MockNamespaceCache) GetVisibleNamespaces(namespace string) []*model.Namespace { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetVisibleNamespaces", namespace) + ret0, _ := ret[0].([]*model.Namespace) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockNamespaceCacheMockRecorder) Name() *gomock.Call { +// GetVisibleNamespaces indicates an expected call of GetVisibleNamespaces +func (mr *MockNamespaceCacheMockRecorder) GetVisibleNamespaces(namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNamespaceCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibleNamespaces", reflect.TypeOf((*MockNamespaceCache)(nil).GetVisibleNamespaces), namespace) } -// Query mocks base method. +// Query mocks base method func (m *MockNamespaceCache) Query(arg0 context.Context, arg1 *api.NamespaceArgs) (uint32, []*model.Namespace, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -591,118 +604,106 @@ func (m *MockNamespaceCache) Query(arg0 context.Context, arg1 *api.NamespaceArgs return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockNamespaceCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockNamespaceCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockNamespaceCache) Update() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) - return ret0 -} - -// Update indicates an expected call of Update. -func (mr *MockNamespaceCacheMockRecorder) Update() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNamespaceCache)(nil).Update)) -} - -// MockServiceCache is a mock of ServiceCache interface. +// MockServiceCache is a mock of ServiceCache interface type MockServiceCache struct { ctrl *gomock.Controller recorder *MockServiceCacheMockRecorder } -// MockServiceCacheMockRecorder is the mock recorder for MockServiceCache. +// MockServiceCacheMockRecorder is the mock recorder for MockServiceCache type MockServiceCacheMockRecorder struct { mock *MockServiceCache } -// NewMockServiceCache creates a new mock instance. +// NewMockServiceCache creates a new mock instance func NewMockServiceCache(ctrl *gomock.Controller) *MockServiceCache { mock := &MockServiceCache{ctrl: ctrl} mock.recorder = &MockServiceCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockServiceCache) EXPECT() *MockServiceCacheMockRecorder { return m.recorder } -// CleanNamespace mocks base method. -func (m *MockServiceCache) CleanNamespace(namespace string) { +// Initialize mocks base method +func (m *MockServiceCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - m.ctrl.Call(m, "CleanNamespace", namespace) + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 } -// CleanNamespace indicates an expected call of CleanNamespace. -func (mr *MockServiceCacheMockRecorder) CleanNamespace(namespace interface{}) *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockServiceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanNamespace", reflect.TypeOf((*MockServiceCache)(nil).CleanNamespace), namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockServiceCache)(nil).Initialize), c) } -// Clear mocks base method. -func (m *MockServiceCache) Clear() error { +// Update mocks base method +func (m *MockServiceCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockServiceCacheMockRecorder) Clear() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockServiceCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockServiceCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceCache)(nil).Update)) } -// Close mocks base method. -func (m *MockServiceCache) Close() error { +// Clear mocks base method +func (m *MockServiceCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Clear") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockServiceCacheMockRecorder) Close() *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockServiceCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockServiceCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockServiceCache)(nil).Clear)) } -// GetAliasFor mocks base method. -func (m *MockServiceCache) GetAliasFor(name, namespace string) *model.Service { +// Name mocks base method +func (m *MockServiceCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAliasFor", name, namespace) - ret0, _ := ret[0].(*model.Service) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetAliasFor indicates an expected call of GetAliasFor. -func (mr *MockServiceCacheMockRecorder) GetAliasFor(name, namespace interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockServiceCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAliasFor", reflect.TypeOf((*MockServiceCache)(nil).GetAliasFor), name, namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServiceCache)(nil).Name)) } -// GetAllNamespaces mocks base method. -func (m *MockServiceCache) GetAllNamespaces() []string { +// Close mocks base method +func (m *MockServiceCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAllNamespaces") - ret0, _ := ret[0].([]string) + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) return ret0 } -// GetAllNamespaces indicates an expected call of GetAllNamespaces. -func (mr *MockServiceCacheMockRecorder) GetAllNamespaces() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockServiceCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamespaces", reflect.TypeOf((*MockServiceCache)(nil).GetAllNamespaces)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockServiceCache)(nil).Close)) } -// GetNamespaceCntInfo mocks base method. +// GetNamespaceCntInfo mocks base method func (m *MockServiceCache) GetNamespaceCntInfo(namespace string) model.NamespaceServiceCount { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNamespaceCntInfo", namespace) @@ -710,41 +711,27 @@ func (m *MockServiceCache) GetNamespaceCntInfo(namespace string) model.Namespace return ret0 } -// GetNamespaceCntInfo indicates an expected call of GetNamespaceCntInfo. +// GetNamespaceCntInfo indicates an expected call of GetNamespaceCntInfo func (mr *MockServiceCacheMockRecorder) GetNamespaceCntInfo(namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceCntInfo", reflect.TypeOf((*MockServiceCache)(nil).GetNamespaceCntInfo), namespace) } -// GetRevisionWorker mocks base method. -func (m *MockServiceCache) GetRevisionWorker() api.ServiceRevisionWorker { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRevisionWorker") - ret0, _ := ret[0].(api.ServiceRevisionWorker) - return ret0 -} - -// GetRevisionWorker indicates an expected call of GetRevisionWorker. -func (mr *MockServiceCacheMockRecorder) GetRevisionWorker() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevisionWorker", reflect.TypeOf((*MockServiceCache)(nil).GetRevisionWorker)) -} - -// GetServiceByCl5Name mocks base method. -func (m *MockServiceCache) GetServiceByCl5Name(cl5Name string) *model.Service { +// GetAllNamespaces mocks base method +func (m *MockServiceCache) GetAllNamespaces() []string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetServiceByCl5Name", cl5Name) - ret0, _ := ret[0].(*model.Service) + ret := m.ctrl.Call(m, "GetAllNamespaces") + ret0, _ := ret[0].([]string) return ret0 } -// GetServiceByCl5Name indicates an expected call of GetServiceByCl5Name. -func (mr *MockServiceCacheMockRecorder) GetServiceByCl5Name(cl5Name interface{}) *gomock.Call { +// GetAllNamespaces indicates an expected call of GetAllNamespaces +func (mr *MockServiceCacheMockRecorder) GetAllNamespaces() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByCl5Name", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByCl5Name), cl5Name) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamespaces", reflect.TypeOf((*MockServiceCache)(nil).GetAllNamespaces)) } -// GetServiceByID mocks base method. +// GetServiceByID mocks base method func (m *MockServiceCache) GetServiceByID(id string) *model.Service { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetServiceByID", id) @@ -752,13 +739,13 @@ func (m *MockServiceCache) GetServiceByID(id string) *model.Service { return ret0 } -// GetServiceByID indicates an expected call of GetServiceByID. +// GetServiceByID indicates an expected call of GetServiceByID func (mr *MockServiceCacheMockRecorder) GetServiceByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByID", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByID), id) } -// GetServiceByName mocks base method. +// GetServiceByName mocks base method func (m *MockServiceCache) GetServiceByName(name, namespace string) *model.Service { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetServiceByName", name, namespace) @@ -766,29 +753,39 @@ func (m *MockServiceCache) GetServiceByName(name, namespace string) *model.Servi return ret0 } -// GetServiceByName indicates an expected call of GetServiceByName. +// GetServiceByName indicates an expected call of GetServiceByName func (mr *MockServiceCacheMockRecorder) GetServiceByName(name, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByName", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByName), name, namespace) } -// GetServicesByFilter mocks base method. -func (m *MockServiceCache) GetServicesByFilter(ctx context.Context, serviceFilters *api.ServiceArgs, instanceFilters *store.InstanceArgs, offset, limit uint32) (uint32, []*model.EnhancedService, error) { +// IteratorServices mocks base method +func (m *MockServiceCache) IteratorServices(iterProc api.ServiceIterProc) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetServicesByFilter", ctx, serviceFilters, instanceFilters, offset, limit) - ret0, _ := ret[0].(uint32) - ret1, _ := ret[1].([]*model.EnhancedService) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "IteratorServices", iterProc) + ret0, _ := ret[0].(error) + return ret0 } -// GetServicesByFilter indicates an expected call of GetServicesByFilter. -func (mr *MockServiceCacheMockRecorder) GetServicesByFilter(ctx, serviceFilters, instanceFilters, offset, limit interface{}) *gomock.Call { +// IteratorServices indicates an expected call of IteratorServices +func (mr *MockServiceCacheMockRecorder) IteratorServices(iterProc interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesByFilter", reflect.TypeOf((*MockServiceCache)(nil).GetServicesByFilter), ctx, serviceFilters, instanceFilters, offset, limit) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorServices", reflect.TypeOf((*MockServiceCache)(nil).IteratorServices), iterProc) +} + +// CleanNamespace mocks base method +func (m *MockServiceCache) CleanNamespace(namespace string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "CleanNamespace", namespace) +} + +// CleanNamespace indicates an expected call of CleanNamespace +func (mr *MockServiceCacheMockRecorder) CleanNamespace(namespace interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanNamespace", reflect.TypeOf((*MockServiceCache)(nil).CleanNamespace), namespace) } -// GetServicesCount mocks base method. +// GetServicesCount mocks base method func (m *MockServiceCache) GetServicesCount() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetServicesCount") @@ -796,55 +793,58 @@ func (m *MockServiceCache) GetServicesCount() int { return ret0 } -// GetServicesCount indicates an expected call of GetServicesCount. +// GetServicesCount indicates an expected call of GetServicesCount func (mr *MockServiceCacheMockRecorder) GetServicesCount() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesCount", reflect.TypeOf((*MockServiceCache)(nil).GetServicesCount)) } -// GetVisibleServicesInOtherNamespace mocks base method. -func (m *MockServiceCache) GetVisibleServicesInOtherNamespace(name, namespace string) []*model.Service { +// GetServiceByCl5Name mocks base method +func (m *MockServiceCache) GetServiceByCl5Name(cl5Name string) *model.Service { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVisibleServicesInOtherNamespace", name, namespace) - ret0, _ := ret[0].([]*model.Service) + ret := m.ctrl.Call(m, "GetServiceByCl5Name", cl5Name) + ret0, _ := ret[0].(*model.Service) return ret0 } -// GetVisibleServicesInOtherNamespace indicates an expected call of GetVisibleServicesInOtherNamespace. -func (mr *MockServiceCacheMockRecorder) GetVisibleServicesInOtherNamespace(name, namespace interface{}) *gomock.Call { +// GetServiceByCl5Name indicates an expected call of GetServiceByCl5Name +func (mr *MockServiceCacheMockRecorder) GetServiceByCl5Name(cl5Name interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibleServicesInOtherNamespace", reflect.TypeOf((*MockServiceCache)(nil).GetVisibleServicesInOtherNamespace), name, namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByCl5Name", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByCl5Name), cl5Name) } -// Initialize mocks base method. -func (m *MockServiceCache) Initialize(c map[string]interface{}) error { +// GetServicesByFilter mocks base method +func (m *MockServiceCache) GetServicesByFilter(ctx context.Context, serviceFilters *api.ServiceArgs, instanceFilters *store.InstanceArgs, offset, limit uint32) (uint32, []*model.EnhancedService, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "GetServicesByFilter", ctx, serviceFilters, instanceFilters, offset, limit) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].([]*model.EnhancedService) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// Initialize indicates an expected call of Initialize. -func (mr *MockServiceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// GetServicesByFilter indicates an expected call of GetServicesByFilter +func (mr *MockServiceCacheMockRecorder) GetServicesByFilter(ctx, serviceFilters, instanceFilters, offset, limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockServiceCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesByFilter", reflect.TypeOf((*MockServiceCache)(nil).GetServicesByFilter), ctx, serviceFilters, instanceFilters, offset, limit) } -// IteratorServices mocks base method. -func (m *MockServiceCache) IteratorServices(iterProc api.ServiceIterProc) error { +// ListServices mocks base method +func (m *MockServiceCache) ListServices(ctx context.Context, ns string) (string, []*model.Service) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IteratorServices", iterProc) - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "ListServices", ctx, ns) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].([]*model.Service) + return ret0, ret1 } -// IteratorServices indicates an expected call of IteratorServices. -func (mr *MockServiceCacheMockRecorder) IteratorServices(iterProc interface{}) *gomock.Call { +// ListServices indicates an expected call of ListServices +func (mr *MockServiceCacheMockRecorder) ListServices(ctx, ns interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorServices", reflect.TypeOf((*MockServiceCache)(nil).IteratorServices), iterProc) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockServiceCache)(nil).ListServices), ctx, ns) } -// ListAllServices mocks base method. +// ListAllServices mocks base method func (m *MockServiceCache) ListAllServices(ctx context.Context) (string, []*model.Service) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListAllServices", ctx) @@ -853,13 +853,13 @@ func (m *MockServiceCache) ListAllServices(ctx context.Context) (string, []*mode return ret0, ret1 } -// ListAllServices indicates an expected call of ListAllServices. +// ListAllServices indicates an expected call of ListAllServices func (mr *MockServiceCacheMockRecorder) ListAllServices(ctx interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllServices", reflect.TypeOf((*MockServiceCache)(nil).ListAllServices), ctx) } -// ListServiceAlias mocks base method. +// ListServiceAlias mocks base method func (m *MockServiceCache) ListServiceAlias(namespace, name string) []*model.Service { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListServiceAlias", namespace, name) @@ -867,93 +867,104 @@ func (m *MockServiceCache) ListServiceAlias(namespace, name string) []*model.Ser return ret0 } -// ListServiceAlias indicates an expected call of ListServiceAlias. +// ListServiceAlias indicates an expected call of ListServiceAlias func (mr *MockServiceCacheMockRecorder) ListServiceAlias(namespace, name interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceAlias", reflect.TypeOf((*MockServiceCache)(nil).ListServiceAlias), namespace, name) } -// ListServices mocks base method. -func (m *MockServiceCache) ListServices(ctx context.Context, ns string) (string, []*model.Service) { +// GetAliasFor mocks base method +func (m *MockServiceCache) GetAliasFor(name, namespace string) *model.Service { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListServices", ctx, ns) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].([]*model.Service) - return ret0, ret1 + ret := m.ctrl.Call(m, "GetAliasFor", name, namespace) + ret0, _ := ret[0].(*model.Service) + return ret0 } -// ListServices indicates an expected call of ListServices. -func (mr *MockServiceCacheMockRecorder) ListServices(ctx, ns interface{}) *gomock.Call { +// GetAliasFor indicates an expected call of GetAliasFor +func (mr *MockServiceCacheMockRecorder) GetAliasFor(name, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockServiceCache)(nil).ListServices), ctx, ns) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAliasFor", reflect.TypeOf((*MockServiceCache)(nil).GetAliasFor), name, namespace) } -// Name mocks base method. -func (m *MockServiceCache) Name() string { +// GetRevisionWorker mocks base method +func (m *MockServiceCache) GetRevisionWorker() api.ServiceRevisionWorker { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetRevisionWorker") + ret0, _ := ret[0].(api.ServiceRevisionWorker) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockServiceCacheMockRecorder) Name() *gomock.Call { +// GetRevisionWorker indicates an expected call of GetRevisionWorker +func (mr *MockServiceCacheMockRecorder) GetRevisionWorker() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServiceCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevisionWorker", reflect.TypeOf((*MockServiceCache)(nil).GetRevisionWorker)) } -// Update mocks base method. -func (m *MockServiceCache) Update() error { +// GetVisibleSameNameServices mocks base method +func (m *MockServiceCache) GetVisibleSameNameServices(name, namespace string) []*model.Service { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetVisibleSameNameServices", name, namespace) + ret0, _ := ret[0].([]*model.Service) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockServiceCacheMockRecorder) Update() *gomock.Call { +// GetVisibleSameNameServices indicates an expected call of GetVisibleSameNameServices +func (mr *MockServiceCacheMockRecorder) GetVisibleSameNameServices(name, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibleSameNameServices", reflect.TypeOf((*MockServiceCache)(nil).GetVisibleSameNameServices), name, namespace) +} + +// GetVisibleServices mocks base method +func (m *MockServiceCache) GetVisibleServices(ctx context.Context, namespace string) []*model.Service { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetVisibleServices", ctx, namespace) + ret0, _ := ret[0].([]*model.Service) + return ret0 +} + +// GetVisibleServices indicates an expected call of GetVisibleServices +func (mr *MockServiceCacheMockRecorder) GetVisibleServices(ctx, namespace interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVisibleServices", reflect.TypeOf((*MockServiceCache)(nil).GetVisibleServices), ctx, namespace) } -// MockServiceRevisionWorker is a mock of ServiceRevisionWorker interface. +// MockServiceRevisionWorker is a mock of ServiceRevisionWorker interface type MockServiceRevisionWorker struct { ctrl *gomock.Controller recorder *MockServiceRevisionWorkerMockRecorder } -// MockServiceRevisionWorkerMockRecorder is the mock recorder for MockServiceRevisionWorker. +// MockServiceRevisionWorkerMockRecorder is the mock recorder for MockServiceRevisionWorker type MockServiceRevisionWorkerMockRecorder struct { mock *MockServiceRevisionWorker } -// NewMockServiceRevisionWorker creates a new mock instance. +// NewMockServiceRevisionWorker creates a new mock instance func NewMockServiceRevisionWorker(ctrl *gomock.Controller) *MockServiceRevisionWorker { mock := &MockServiceRevisionWorker{ctrl: ctrl} mock.recorder = &MockServiceRevisionWorkerMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockServiceRevisionWorker) EXPECT() *MockServiceRevisionWorkerMockRecorder { return m.recorder } -// GetServiceInstanceRevision mocks base method. -func (m *MockServiceRevisionWorker) GetServiceInstanceRevision(serviceID string) string { +// Notify mocks base method +func (m *MockServiceRevisionWorker) Notify(serviceID string, valid bool) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetServiceInstanceRevision", serviceID) - ret0, _ := ret[0].(string) - return ret0 + m.ctrl.Call(m, "Notify", serviceID, valid) } -// GetServiceInstanceRevision indicates an expected call of GetServiceInstanceRevision. -func (mr *MockServiceRevisionWorkerMockRecorder) GetServiceInstanceRevision(serviceID interface{}) *gomock.Call { +// Notify indicates an expected call of Notify +func (mr *MockServiceRevisionWorkerMockRecorder) Notify(serviceID, valid interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceInstanceRevision", reflect.TypeOf((*MockServiceRevisionWorker)(nil).GetServiceInstanceRevision), serviceID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockServiceRevisionWorker)(nil).Notify), serviceID, valid) } -// GetServiceRevisionCount mocks base method. +// GetServiceRevisionCount mocks base method func (m *MockServiceRevisionWorker) GetServiceRevisionCount() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetServiceRevisionCount") @@ -961,155 +972,185 @@ func (m *MockServiceRevisionWorker) GetServiceRevisionCount() int { return ret0 } -// GetServiceRevisionCount indicates an expected call of GetServiceRevisionCount. +// GetServiceRevisionCount indicates an expected call of GetServiceRevisionCount func (mr *MockServiceRevisionWorkerMockRecorder) GetServiceRevisionCount() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceRevisionCount", reflect.TypeOf((*MockServiceRevisionWorker)(nil).GetServiceRevisionCount)) } -// Notify mocks base method. -func (m *MockServiceRevisionWorker) Notify(serviceID string, valid bool) { +// GetServiceInstanceRevision mocks base method +func (m *MockServiceRevisionWorker) GetServiceInstanceRevision(serviceID string) string { m.ctrl.T.Helper() - m.ctrl.Call(m, "Notify", serviceID, valid) + ret := m.ctrl.Call(m, "GetServiceInstanceRevision", serviceID) + ret0, _ := ret[0].(string) + return ret0 } -// Notify indicates an expected call of Notify. -func (mr *MockServiceRevisionWorkerMockRecorder) Notify(serviceID, valid interface{}) *gomock.Call { +// GetServiceInstanceRevision indicates an expected call of GetServiceInstanceRevision +func (mr *MockServiceRevisionWorkerMockRecorder) GetServiceInstanceRevision(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockServiceRevisionWorker)(nil).Notify), serviceID, valid) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceInstanceRevision", reflect.TypeOf((*MockServiceRevisionWorker)(nil).GetServiceInstanceRevision), serviceID) } -// MockServiceContractCache is a mock of ServiceContractCache interface. +// MockServiceContractCache is a mock of ServiceContractCache interface type MockServiceContractCache struct { ctrl *gomock.Controller recorder *MockServiceContractCacheMockRecorder } -// MockServiceContractCacheMockRecorder is the mock recorder for MockServiceContractCache. +// MockServiceContractCacheMockRecorder is the mock recorder for MockServiceContractCache type MockServiceContractCacheMockRecorder struct { mock *MockServiceContractCache } -// NewMockServiceContractCache creates a new mock instance. +// NewMockServiceContractCache creates a new mock instance func NewMockServiceContractCache(ctrl *gomock.Controller) *MockServiceContractCache { mock := &MockServiceContractCache{ctrl: ctrl} mock.recorder = &MockServiceContractCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockServiceContractCache) EXPECT() *MockServiceContractCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockServiceContractCache) Clear() error { +// Initialize mocks base method +func (m *MockServiceContractCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockServiceContractCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockServiceContractCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockServiceContractCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockServiceContractCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockServiceContractCache) Close() error { +// Update mocks base method +func (m *MockServiceContractCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockServiceContractCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockServiceContractCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockServiceContractCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceContractCache)(nil).Update)) } -// Get mocks base method. -func (m *MockServiceContractCache) Get(ctx context.Context, req *model.ServiceContract) *model.EnrichServiceContract { +// Clear mocks base method +func (m *MockServiceContractCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", ctx, req) - ret0, _ := ret[0].(*model.EnrichServiceContract) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// Get indicates an expected call of Get. -func (mr *MockServiceContractCacheMockRecorder) Get(ctx, req interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockServiceContractCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockServiceContractCache)(nil).Get), ctx, req) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockServiceContractCache)(nil).Clear)) } -// Initialize mocks base method. -func (m *MockServiceContractCache) Initialize(c map[string]interface{}) error { +// Name mocks base method +func (m *MockServiceContractCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockServiceContractCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockServiceContractCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockServiceContractCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServiceContractCache)(nil).Name)) } -// Name mocks base method. -func (m *MockServiceContractCache) Name() string { +// Close mocks base method +func (m *MockServiceContractCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockServiceContractCacheMockRecorder) Name() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockServiceContractCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServiceContractCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockServiceContractCache)(nil).Close)) } -// Update mocks base method. -func (m *MockServiceContractCache) Update() error { +// Get mocks base method +func (m *MockServiceContractCache) Get(ctx context.Context, req *model.ServiceContract) *model.EnrichServiceContract { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Get", ctx, req) + ret0, _ := ret[0].(*model.EnrichServiceContract) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockServiceContractCacheMockRecorder) Update() *gomock.Call { +// Get indicates an expected call of Get +func (mr *MockServiceContractCacheMockRecorder) Get(ctx, req interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceContractCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockServiceContractCache)(nil).Get), ctx, req) } -// MockInstanceCache is a mock of InstanceCache interface. +// MockInstanceCache is a mock of InstanceCache interface type MockInstanceCache struct { ctrl *gomock.Controller recorder *MockInstanceCacheMockRecorder } -// MockInstanceCacheMockRecorder is the mock recorder for MockInstanceCache. +// MockInstanceCacheMockRecorder is the mock recorder for MockInstanceCache type MockInstanceCacheMockRecorder struct { mock *MockInstanceCache } -// NewMockInstanceCache creates a new mock instance. +// NewMockInstanceCache creates a new mock instance func NewMockInstanceCache(ctrl *gomock.Controller) *MockInstanceCache { mock := &MockInstanceCache{ctrl: ctrl} mock.recorder = &MockInstanceCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockInstanceCache) EXPECT() *MockInstanceCacheMockRecorder { return m.recorder } -// Clear mocks base method. +// Initialize mocks base method +func (m *MockInstanceCache) Initialize(c map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialize indicates an expected call of Initialize +func (mr *MockInstanceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockInstanceCache)(nil).Initialize), c) +} + +// Update mocks base method +func (m *MockInstanceCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (mr *MockInstanceCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceCache)(nil).Update)) +} + +// Clear mocks base method func (m *MockInstanceCache) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -1117,41 +1158,41 @@ func (m *MockInstanceCache) Clear() error { return ret0 } -// Clear indicates an expected call of Clear. +// Clear indicates an expected call of Clear func (mr *MockInstanceCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockInstanceCache)(nil).Clear)) } -// Close mocks base method. -func (m *MockInstanceCache) Close() error { +// Name mocks base method +func (m *MockInstanceCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockInstanceCacheMockRecorder) Close() *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockInstanceCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockInstanceCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockInstanceCache)(nil).Name)) } -// DiscoverServiceInstances mocks base method. -func (m *MockInstanceCache) DiscoverServiceInstances(serviceID string, onlyHealthy bool) []*model.Instance { +// Close mocks base method +func (m *MockInstanceCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DiscoverServiceInstances", serviceID, onlyHealthy) - ret0, _ := ret[0].([]*model.Instance) + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) return ret0 } -// DiscoverServiceInstances indicates an expected call of DiscoverServiceInstances. -func (mr *MockInstanceCacheMockRecorder) DiscoverServiceInstances(serviceID, onlyHealthy interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockInstanceCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverServiceInstances", reflect.TypeOf((*MockInstanceCache)(nil).DiscoverServiceInstances), serviceID, onlyHealthy) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockInstanceCache)(nil).Close)) } -// GetInstance mocks base method. +// GetInstance mocks base method func (m *MockInstanceCache) GetInstance(instanceID string) *model.Instance { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetInstance", instanceID) @@ -1159,27 +1200,27 @@ func (m *MockInstanceCache) GetInstance(instanceID string) *model.Instance { return ret0 } -// GetInstance indicates an expected call of GetInstance. +// GetInstance indicates an expected call of GetInstance func (mr *MockInstanceCacheMockRecorder) GetInstance(instanceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstance", reflect.TypeOf((*MockInstanceCache)(nil).GetInstance), instanceID) } -// GetInstanceLabels mocks base method. -func (m *MockInstanceCache) GetInstanceLabels(serviceID string) *service_manage.InstanceLabels { +// GetInstancesByServiceID mocks base method +func (m *MockInstanceCache) GetInstancesByServiceID(serviceID string) []*model.Instance { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceLabels", serviceID) - ret0, _ := ret[0].(*service_manage.InstanceLabels) + ret := m.ctrl.Call(m, "GetInstancesByServiceID", serviceID) + ret0, _ := ret[0].([]*model.Instance) return ret0 } -// GetInstanceLabels indicates an expected call of GetInstanceLabels. -func (mr *MockInstanceCacheMockRecorder) GetInstanceLabels(serviceID interface{}) *gomock.Call { +// GetInstancesByServiceID indicates an expected call of GetInstancesByServiceID +func (mr *MockInstanceCacheMockRecorder) GetInstancesByServiceID(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceLabels", reflect.TypeOf((*MockInstanceCache)(nil).GetInstanceLabels), serviceID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesByServiceID", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesByServiceID), serviceID) } -// GetInstances mocks base method. +// GetInstances mocks base method func (m *MockInstanceCache) GetInstances(serviceID string) *model.ServiceInstances { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetInstances", serviceID) @@ -1187,27 +1228,41 @@ func (m *MockInstanceCache) GetInstances(serviceID string) *model.ServiceInstanc return ret0 } -// GetInstances indicates an expected call of GetInstances. +// GetInstances indicates an expected call of GetInstances func (mr *MockInstanceCacheMockRecorder) GetInstances(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstances", reflect.TypeOf((*MockInstanceCache)(nil).GetInstances), serviceID) } -// GetInstancesByServiceID mocks base method. -func (m *MockInstanceCache) GetInstancesByServiceID(serviceID string) []*model.Instance { +// IteratorInstances mocks base method +func (m *MockInstanceCache) IteratorInstances(iterProc api.InstanceIterProc) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstancesByServiceID", serviceID) - ret0, _ := ret[0].([]*model.Instance) + ret := m.ctrl.Call(m, "IteratorInstances", iterProc) + ret0, _ := ret[0].(error) return ret0 } -// GetInstancesByServiceID indicates an expected call of GetInstancesByServiceID. -func (mr *MockInstanceCacheMockRecorder) GetInstancesByServiceID(serviceID interface{}) *gomock.Call { +// IteratorInstances indicates an expected call of IteratorInstances +func (mr *MockInstanceCacheMockRecorder) IteratorInstances(iterProc interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesByServiceID", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesByServiceID), serviceID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstances", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstances), iterProc) } -// GetInstancesCount mocks base method. +// IteratorInstancesWithService mocks base method +func (m *MockInstanceCache) IteratorInstancesWithService(serviceID string, iterProc api.InstanceIterProc) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IteratorInstancesWithService", serviceID, iterProc) + ret0, _ := ret[0].(error) + return ret0 +} + +// IteratorInstancesWithService indicates an expected call of IteratorInstancesWithService +func (mr *MockInstanceCacheMockRecorder) IteratorInstancesWithService(serviceID, iterProc interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstancesWithService", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstancesWithService), serviceID, iterProc) +} + +// GetInstancesCount mocks base method func (m *MockInstanceCache) GetInstancesCount() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetInstancesCount") @@ -1215,13 +1270,13 @@ func (m *MockInstanceCache) GetInstancesCount() int { return ret0 } -// GetInstancesCount indicates an expected call of GetInstancesCount. +// GetInstancesCount indicates an expected call of GetInstancesCount func (mr *MockInstanceCacheMockRecorder) GetInstancesCount() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesCount", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesCount)) } -// GetInstancesCountByServiceID mocks base method. +// GetInstancesCountByServiceID mocks base method func (m *MockInstanceCache) GetInstancesCountByServiceID(serviceID string) model.InstanceCount { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetInstancesCountByServiceID", serviceID) @@ -1229,13 +1284,13 @@ func (m *MockInstanceCache) GetInstancesCountByServiceID(serviceID string) model return ret0 } -// GetInstancesCountByServiceID indicates an expected call of GetInstancesCountByServiceID. +// GetInstancesCountByServiceID indicates an expected call of GetInstancesCountByServiceID func (mr *MockInstanceCacheMockRecorder) GetInstancesCountByServiceID(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesCountByServiceID", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesCountByServiceID), serviceID) } -// GetServicePorts mocks base method. +// GetServicePorts mocks base method func (m *MockInstanceCache) GetServicePorts(serviceID string) []*model.ServicePort { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetServicePorts", serviceID) @@ -1243,69 +1298,27 @@ func (m *MockInstanceCache) GetServicePorts(serviceID string) []*model.ServicePo return ret0 } -// GetServicePorts indicates an expected call of GetServicePorts. +// GetServicePorts indicates an expected call of GetServicePorts func (mr *MockInstanceCacheMockRecorder) GetServicePorts(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicePorts", reflect.TypeOf((*MockInstanceCache)(nil).GetServicePorts), serviceID) } -// Initialize mocks base method. -func (m *MockInstanceCache) Initialize(c map[string]interface{}) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) - return ret0 -} - -// Initialize indicates an expected call of Initialize. -func (mr *MockInstanceCacheMockRecorder) Initialize(c interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockInstanceCache)(nil).Initialize), c) -} - -// IteratorInstances mocks base method. -func (m *MockInstanceCache) IteratorInstances(iterProc api.InstanceIterProc) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IteratorInstances", iterProc) - ret0, _ := ret[0].(error) - return ret0 -} - -// IteratorInstances indicates an expected call of IteratorInstances. -func (mr *MockInstanceCacheMockRecorder) IteratorInstances(iterProc interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstances", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstances), iterProc) -} - -// IteratorInstancesWithService mocks base method. -func (m *MockInstanceCache) IteratorInstancesWithService(serviceID string, iterProc api.InstanceIterProc) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IteratorInstancesWithService", serviceID, iterProc) - ret0, _ := ret[0].(error) - return ret0 -} - -// IteratorInstancesWithService indicates an expected call of IteratorInstancesWithService. -func (mr *MockInstanceCacheMockRecorder) IteratorInstancesWithService(serviceID, iterProc interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstancesWithService", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstancesWithService), serviceID, iterProc) -} - -// Name mocks base method. -func (m *MockInstanceCache) Name() string { +// GetInstanceLabels mocks base method +func (m *MockInstanceCache) GetInstanceLabels(serviceID string) *service_manage.InstanceLabels { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetInstanceLabels", serviceID) + ret0, _ := ret[0].(*service_manage.InstanceLabels) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockInstanceCacheMockRecorder) Name() *gomock.Call { +// GetInstanceLabels indicates an expected call of GetInstanceLabels +func (mr *MockInstanceCacheMockRecorder) GetInstanceLabels(serviceID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockInstanceCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceLabels", reflect.TypeOf((*MockInstanceCache)(nil).GetInstanceLabels), serviceID) } -// QueryInstances mocks base method. +// QueryInstances mocks base method func (m *MockInstanceCache) QueryInstances(filter, metaFilter map[string]string, offset, limit uint32) (uint32, []*model.Instance, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryInstances", filter, metaFilter, offset, limit) @@ -1315,134 +1328,120 @@ func (m *MockInstanceCache) QueryInstances(filter, metaFilter map[string]string, return ret0, ret1, ret2 } -// QueryInstances indicates an expected call of QueryInstances. +// QueryInstances indicates an expected call of QueryInstances func (mr *MockInstanceCacheMockRecorder) QueryInstances(filter, metaFilter, offset, limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryInstances", reflect.TypeOf((*MockInstanceCache)(nil).QueryInstances), filter, metaFilter, offset, limit) } -// Update mocks base method. -func (m *MockInstanceCache) Update() error { +// DiscoverServiceInstances mocks base method +func (m *MockInstanceCache) DiscoverServiceInstances(serviceID string, onlyHealthy bool) []*model.Instance { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "DiscoverServiceInstances", serviceID, onlyHealthy) + ret0, _ := ret[0].([]*model.Instance) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockInstanceCacheMockRecorder) Update() *gomock.Call { +// DiscoverServiceInstances indicates an expected call of DiscoverServiceInstances +func (mr *MockInstanceCacheMockRecorder) DiscoverServiceInstances(serviceID, onlyHealthy interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverServiceInstances", reflect.TypeOf((*MockInstanceCache)(nil).DiscoverServiceInstances), serviceID, onlyHealthy) } -// MockFaultDetectCache is a mock of FaultDetectCache interface. +// MockFaultDetectCache is a mock of FaultDetectCache interface type MockFaultDetectCache struct { ctrl *gomock.Controller recorder *MockFaultDetectCacheMockRecorder } -// MockFaultDetectCacheMockRecorder is the mock recorder for MockFaultDetectCache. +// MockFaultDetectCacheMockRecorder is the mock recorder for MockFaultDetectCache type MockFaultDetectCacheMockRecorder struct { mock *MockFaultDetectCache } -// NewMockFaultDetectCache creates a new mock instance. +// NewMockFaultDetectCache creates a new mock instance func NewMockFaultDetectCache(ctrl *gomock.Controller) *MockFaultDetectCache { mock := &MockFaultDetectCache{ctrl: ctrl} mock.recorder = &MockFaultDetectCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockFaultDetectCache) EXPECT() *MockFaultDetectCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockFaultDetectCache) Clear() error { +// Initialize mocks base method +func (m *MockFaultDetectCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockFaultDetectCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockFaultDetectCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockFaultDetectCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockFaultDetectCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockFaultDetectCache) Close() error { +// Update mocks base method +func (m *MockFaultDetectCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockFaultDetectCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockFaultDetectCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFaultDetectCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockFaultDetectCache)(nil).Update)) } -// GetFaultDetectConfig mocks base method. -func (m *MockFaultDetectCache) GetFaultDetectConfig(svcName, namespace string) *model.ServiceWithFaultDetectRules { +// Clear mocks base method +func (m *MockFaultDetectCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFaultDetectConfig", svcName, namespace) - ret0, _ := ret[0].(*model.ServiceWithFaultDetectRules) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetFaultDetectConfig indicates an expected call of GetFaultDetectConfig. -func (mr *MockFaultDetectCacheMockRecorder) GetFaultDetectConfig(svcName, namespace interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockFaultDetectCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFaultDetectConfig", reflect.TypeOf((*MockFaultDetectCache)(nil).GetFaultDetectConfig), svcName, namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockFaultDetectCache)(nil).Clear)) } -// GetRule mocks base method. -func (m *MockFaultDetectCache) GetRule(id string) *model.FaultDetectRule { +// Name mocks base method +func (m *MockFaultDetectCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRule", id) - ret0, _ := ret[0].(*model.FaultDetectRule) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetRule indicates an expected call of GetRule. -func (mr *MockFaultDetectCacheMockRecorder) GetRule(id interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockFaultDetectCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockFaultDetectCache)(nil).GetRule), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFaultDetectCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockFaultDetectCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockFaultDetectCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockFaultDetectCacheMockRecorder) Initialize(c interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockFaultDetectCache)(nil).Initialize), c) -} - -// Name mocks base method. -func (m *MockFaultDetectCache) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockFaultDetectCacheMockRecorder) Name() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockFaultDetectCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFaultDetectCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFaultDetectCache)(nil).Close)) } -// Query mocks base method. +// Query mocks base method func (m *MockFaultDetectCache) Query(arg0 context.Context, arg1 *api.FaultDetectArgs) (uint32, []*model.FaultDetectRule, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -1452,121 +1451,106 @@ func (m *MockFaultDetectCache) Query(arg0 context.Context, arg1 *api.FaultDetect return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockFaultDetectCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockFaultDetectCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockFaultDetectCache) Update() error { +// GetFaultDetectConfig mocks base method +func (m *MockFaultDetectCache) GetFaultDetectConfig(svcName, namespace string) *model.ServiceWithFaultDetectRules { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetFaultDetectConfig", svcName, namespace) + ret0, _ := ret[0].(*model.ServiceWithFaultDetectRules) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockFaultDetectCacheMockRecorder) Update() *gomock.Call { +// GetFaultDetectConfig indicates an expected call of GetFaultDetectConfig +func (mr *MockFaultDetectCacheMockRecorder) GetFaultDetectConfig(svcName, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockFaultDetectCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFaultDetectConfig", reflect.TypeOf((*MockFaultDetectCache)(nil).GetFaultDetectConfig), svcName, namespace) +} + +// GetRule mocks base method +func (m *MockFaultDetectCache) GetRule(id string) *model.FaultDetectRule { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRule", id) + ret0, _ := ret[0].(*model.FaultDetectRule) + return ret0 +} + +// GetRule indicates an expected call of GetRule +func (mr *MockFaultDetectCacheMockRecorder) GetRule(id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockFaultDetectCache)(nil).GetRule), id) } -// MockLaneCache is a mock of LaneCache interface. +// MockLaneCache is a mock of LaneCache interface type MockLaneCache struct { ctrl *gomock.Controller recorder *MockLaneCacheMockRecorder } -// MockLaneCacheMockRecorder is the mock recorder for MockLaneCache. +// MockLaneCacheMockRecorder is the mock recorder for MockLaneCache type MockLaneCacheMockRecorder struct { mock *MockLaneCache } -// NewMockLaneCache creates a new mock instance. +// NewMockLaneCache creates a new mock instance func NewMockLaneCache(ctrl *gomock.Controller) *MockLaneCache { mock := &MockLaneCache{ctrl: ctrl} mock.recorder = &MockLaneCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockLaneCache) EXPECT() *MockLaneCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockLaneCache) Clear() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") - ret0, _ := ret[0].(error) - return ret0 -} - -// Clear indicates an expected call of Clear. -func (mr *MockLaneCacheMockRecorder) Clear() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockLaneCache)(nil).Clear)) -} - -// Close mocks base method. -func (m *MockLaneCache) Close() error { +// Initialize mocks base method +func (m *MockLaneCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockLaneCacheMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockLaneCache)(nil).Close)) -} - -// GetLaneRules mocks base method. -func (m *MockLaneCache) GetLaneRules(serviceKey *model.Service) ([]*model.LaneGroupProto, string) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLaneRules", serviceKey) - ret0, _ := ret[0].([]*model.LaneGroupProto) - ret1, _ := ret[1].(string) - return ret0, ret1 -} - -// GetLaneRules indicates an expected call of GetLaneRules. -func (mr *MockLaneCacheMockRecorder) GetLaneRules(serviceKey interface{}) *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockLaneCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaneRules", reflect.TypeOf((*MockLaneCache)(nil).GetLaneRules), serviceKey) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockLaneCache)(nil).Initialize), c) } -// GetRule mocks base method. -func (m *MockLaneCache) GetRule(id string) *model.LaneGroup { +// Update mocks base method +func (m *MockLaneCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRule", id) - ret0, _ := ret[0].(*model.LaneGroup) + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) return ret0 } -// GetRule indicates an expected call of GetRule. -func (mr *MockLaneCacheMockRecorder) GetRule(id interface{}) *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockLaneCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockLaneCache)(nil).GetRule), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLaneCache)(nil).Update)) } -// Initialize mocks base method. -func (m *MockLaneCache) Initialize(c map[string]interface{}) error { +// Clear mocks base method +func (m *MockLaneCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Clear") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockLaneCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockLaneCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockLaneCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockLaneCache)(nil).Clear)) } -// Name mocks base method. +// Name mocks base method func (m *MockLaneCache) Name() string { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Name") @@ -1574,13 +1558,27 @@ func (m *MockLaneCache) Name() string { return ret0 } -// Name indicates an expected call of Name. +// Name indicates an expected call of Name func (mr *MockLaneCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockLaneCache)(nil).Name)) } -// Query mocks base method. +// Close mocks base method +func (m *MockLaneCache) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close +func (mr *MockLaneCacheMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockLaneCache)(nil).Close)) +} + +// Query mocks base method func (m *MockLaneCache) Query(arg0 context.Context, arg1 *api.LaneGroupArgs) (uint32, []*model.LaneGroupProto, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -1590,50 +1588,93 @@ func (m *MockLaneCache) Query(arg0 context.Context, arg1 *api.LaneGroupArgs) (ui return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockLaneCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockLaneCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockLaneCache) Update() error { +// GetLaneRules mocks base method +func (m *MockLaneCache) GetLaneRules(serviceKey *model.Service) ([]*model.LaneGroupProto, string) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetLaneRules", serviceKey) + ret0, _ := ret[0].([]*model.LaneGroupProto) + ret1, _ := ret[1].(string) + return ret0, ret1 +} + +// GetLaneRules indicates an expected call of GetLaneRules +func (mr *MockLaneCacheMockRecorder) GetLaneRules(serviceKey interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaneRules", reflect.TypeOf((*MockLaneCache)(nil).GetLaneRules), serviceKey) +} + +// GetRule mocks base method +func (m *MockLaneCache) GetRule(id string) *model.LaneGroup { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRule", id) + ret0, _ := ret[0].(*model.LaneGroup) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockLaneCacheMockRecorder) Update() *gomock.Call { +// GetRule indicates an expected call of GetRule +func (mr *MockLaneCacheMockRecorder) GetRule(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLaneCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockLaneCache)(nil).GetRule), id) } -// MockRoutingConfigCache is a mock of RoutingConfigCache interface. +// MockRoutingConfigCache is a mock of RoutingConfigCache interface type MockRoutingConfigCache struct { ctrl *gomock.Controller recorder *MockRoutingConfigCacheMockRecorder } -// MockRoutingConfigCacheMockRecorder is the mock recorder for MockRoutingConfigCache. +// MockRoutingConfigCacheMockRecorder is the mock recorder for MockRoutingConfigCache type MockRoutingConfigCacheMockRecorder struct { mock *MockRoutingConfigCache } -// NewMockRoutingConfigCache creates a new mock instance. +// NewMockRoutingConfigCache creates a new mock instance func NewMockRoutingConfigCache(ctrl *gomock.Controller) *MockRoutingConfigCache { mock := &MockRoutingConfigCache{ctrl: ctrl} mock.recorder = &MockRoutingConfigCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRoutingConfigCache) EXPECT() *MockRoutingConfigCacheMockRecorder { return m.recorder } -// Clear mocks base method. +// Initialize mocks base method +func (m *MockRoutingConfigCache) Initialize(c map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialize indicates an expected call of Initialize +func (mr *MockRoutingConfigCacheMockRecorder) Initialize(c interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRoutingConfigCache)(nil).Initialize), c) +} + +// Update mocks base method +func (m *MockRoutingConfigCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (mr *MockRoutingConfigCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoutingConfigCache)(nil).Update)) +} + +// Clear mocks base method func (m *MockRoutingConfigCache) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -1641,43 +1682,41 @@ func (m *MockRoutingConfigCache) Clear() error { return ret0 } -// Clear indicates an expected call of Clear. +// Clear indicates an expected call of Clear func (mr *MockRoutingConfigCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRoutingConfigCache)(nil).Clear)) } -// Close mocks base method. -func (m *MockRoutingConfigCache) Close() error { +// Name mocks base method +func (m *MockRoutingConfigCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockRoutingConfigCacheMockRecorder) Close() *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockRoutingConfigCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRoutingConfigCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRoutingConfigCache)(nil).Name)) } -// GetNearbyRouteRule mocks base method. -func (m *MockRoutingConfigCache) GetNearbyRouteRule(service, namespace string) ([]*traffic_manage.RouteRule, string, error) { +// Close mocks base method +func (m *MockRoutingConfigCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNearbyRouteRule", service, namespace) - ret0, _ := ret[0].([]*traffic_manage.RouteRule) - ret1, _ := ret[1].(string) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 } -// GetNearbyRouteRule indicates an expected call of GetNearbyRouteRule. -func (mr *MockRoutingConfigCacheMockRecorder) GetNearbyRouteRule(service, namespace interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockRoutingConfigCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNearbyRouteRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetNearbyRouteRule), service, namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRoutingConfigCache)(nil).Close)) } -// GetRouterConfig mocks base method. +// GetRouterConfig mocks base method func (m *MockRoutingConfigCache) GetRouterConfig(id, service, namespace string) (*traffic_manage.Routing, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRouterConfig", id, service, namespace) @@ -1686,13 +1725,13 @@ func (m *MockRoutingConfigCache) GetRouterConfig(id, service, namespace string) return ret0, ret1 } -// GetRouterConfig indicates an expected call of GetRouterConfig. +// GetRouterConfig indicates an expected call of GetRouterConfig func (mr *MockRoutingConfigCacheMockRecorder) GetRouterConfig(id, service, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouterConfig", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRouterConfig), id, service, namespace) } -// GetRouterConfigV2 mocks base method. +// GetRouterConfigV2 mocks base method func (m *MockRoutingConfigCache) GetRouterConfigV2(id, service, namespace string) (*traffic_manage.Routing, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRouterConfigV2", id, service, namespace) @@ -1701,13 +1740,29 @@ func (m *MockRoutingConfigCache) GetRouterConfigV2(id, service, namespace string return ret0, ret1 } -// GetRouterConfigV2 indicates an expected call of GetRouterConfigV2. +// GetRouterConfigV2 indicates an expected call of GetRouterConfigV2 func (mr *MockRoutingConfigCacheMockRecorder) GetRouterConfigV2(id, service, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouterConfigV2", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRouterConfigV2), id, service, namespace) } -// GetRoutingConfigCount mocks base method. +// GetNearbyRouteRule mocks base method +func (m *MockRoutingConfigCache) GetNearbyRouteRule(service, namespace string) ([]*traffic_manage.RouteRule, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNearbyRouteRule", service, namespace) + ret0, _ := ret[0].([]*traffic_manage.RouteRule) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetNearbyRouteRule indicates an expected call of GetNearbyRouteRule +func (mr *MockRoutingConfigCacheMockRecorder) GetNearbyRouteRule(service, namespace interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNearbyRouteRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetNearbyRouteRule), service, namespace) +} + +// GetRoutingConfigCount mocks base method func (m *MockRoutingConfigCache) GetRoutingConfigCount() int { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRoutingConfigCount") @@ -1715,41 +1770,43 @@ func (m *MockRoutingConfigCache) GetRoutingConfigCount() int { return ret0 } -// GetRoutingConfigCount indicates an expected call of GetRoutingConfigCount. +// GetRoutingConfigCount indicates an expected call of GetRoutingConfigCount func (mr *MockRoutingConfigCacheMockRecorder) GetRoutingConfigCount() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigCount", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRoutingConfigCount)) } -// GetRule mocks base method. -func (m *MockRoutingConfigCache) GetRule(id string) *model.ExtendRouterConfig { +// QueryRoutingConfigsV2 mocks base method +func (m *MockRoutingConfigCache) QueryRoutingConfigsV2(arg0 context.Context, arg1 *api.RoutingArgs) (uint32, []*model.ExtendRouterConfig, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRule", id) - ret0, _ := ret[0].(*model.ExtendRouterConfig) - return ret0 + ret := m.ctrl.Call(m, "QueryRoutingConfigsV2", arg0, arg1) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].([]*model.ExtendRouterConfig) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// GetRule indicates an expected call of GetRule. -func (mr *MockRoutingConfigCacheMockRecorder) GetRule(id interface{}) *gomock.Call { +// QueryRoutingConfigsV2 indicates an expected call of QueryRoutingConfigsV2 +func (mr *MockRoutingConfigCacheMockRecorder) QueryRoutingConfigsV2(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRule), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRoutingConfigsV2", reflect.TypeOf((*MockRoutingConfigCache)(nil).QueryRoutingConfigsV2), arg0, arg1) } -// Initialize mocks base method. -func (m *MockRoutingConfigCache) Initialize(c map[string]interface{}) error { +// ListRouterRule mocks base method +func (m *MockRoutingConfigCache) ListRouterRule(service, namespace string) []*model.ExtendRouterConfig { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "ListRouterRule", service, namespace) + ret0, _ := ret[0].([]*model.ExtendRouterConfig) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockRoutingConfigCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// ListRouterRule indicates an expected call of ListRouterRule +func (mr *MockRoutingConfigCacheMockRecorder) ListRouterRule(service, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRoutingConfigCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRouterRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).ListRouterRule), service, namespace) } -// IsConvertFromV1 mocks base method. +// IsConvertFromV1 mocks base method func (m *MockRoutingConfigCache) IsConvertFromV1(id string) (string, bool) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsConvertFromV1", id) @@ -1758,217 +1815,159 @@ func (m *MockRoutingConfigCache) IsConvertFromV1(id string) (string, bool) { return ret0, ret1 } -// IsConvertFromV1 indicates an expected call of IsConvertFromV1. +// IsConvertFromV1 indicates an expected call of IsConvertFromV1 func (mr *MockRoutingConfigCacheMockRecorder) IsConvertFromV1(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConvertFromV1", reflect.TypeOf((*MockRoutingConfigCache)(nil).IsConvertFromV1), id) } -// IteratorRouterRule mocks base method. +// IteratorRouterRule mocks base method func (m *MockRoutingConfigCache) IteratorRouterRule(iterProc api.RouterRuleIterProc) { m.ctrl.T.Helper() m.ctrl.Call(m, "IteratorRouterRule", iterProc) } -// IteratorRouterRule indicates an expected call of IteratorRouterRule. +// IteratorRouterRule indicates an expected call of IteratorRouterRule func (mr *MockRoutingConfigCacheMockRecorder) IteratorRouterRule(iterProc interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorRouterRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).IteratorRouterRule), iterProc) } -// ListRouterRule mocks base method. -func (m *MockRoutingConfigCache) ListRouterRule(service, namespace string) []*model.ExtendRouterConfig { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListRouterRule", service, namespace) - ret0, _ := ret[0].([]*model.ExtendRouterConfig) - return ret0 -} - -// ListRouterRule indicates an expected call of ListRouterRule. -func (mr *MockRoutingConfigCacheMockRecorder) ListRouterRule(service, namespace interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRouterRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).ListRouterRule), service, namespace) -} - -// Name mocks base method. -func (m *MockRoutingConfigCache) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockRoutingConfigCacheMockRecorder) Name() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRoutingConfigCache)(nil).Name)) -} - -// QueryRoutingConfigsV2 mocks base method. -func (m *MockRoutingConfigCache) QueryRoutingConfigsV2(arg0 context.Context, arg1 *api.RoutingArgs) (uint32, []*model.ExtendRouterConfig, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryRoutingConfigsV2", arg0, arg1) - ret0, _ := ret[0].(uint32) - ret1, _ := ret[1].([]*model.ExtendRouterConfig) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// QueryRoutingConfigsV2 indicates an expected call of QueryRoutingConfigsV2. -func (mr *MockRoutingConfigCacheMockRecorder) QueryRoutingConfigsV2(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRoutingConfigsV2", reflect.TypeOf((*MockRoutingConfigCache)(nil).QueryRoutingConfigsV2), arg0, arg1) -} - -// Update mocks base method. -func (m *MockRoutingConfigCache) Update() error { +// GetRule mocks base method +func (m *MockRoutingConfigCache) GetRule(id string) *model.ExtendRouterConfig { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetRule", id) + ret0, _ := ret[0].(*model.ExtendRouterConfig) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockRoutingConfigCacheMockRecorder) Update() *gomock.Call { +// GetRule indicates an expected call of GetRule +func (mr *MockRoutingConfigCacheMockRecorder) GetRule(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoutingConfigCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRule), id) } -// MockRateLimitCache is a mock of RateLimitCache interface. +// MockRateLimitCache is a mock of RateLimitCache interface type MockRateLimitCache struct { ctrl *gomock.Controller recorder *MockRateLimitCacheMockRecorder } -// MockRateLimitCacheMockRecorder is the mock recorder for MockRateLimitCache. +// MockRateLimitCacheMockRecorder is the mock recorder for MockRateLimitCache type MockRateLimitCacheMockRecorder struct { mock *MockRateLimitCache } -// NewMockRateLimitCache creates a new mock instance. +// NewMockRateLimitCache creates a new mock instance func NewMockRateLimitCache(ctrl *gomock.Controller) *MockRateLimitCache { mock := &MockRateLimitCache{ctrl: ctrl} mock.recorder = &MockRateLimitCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRateLimitCache) EXPECT() *MockRateLimitCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockRateLimitCache) Clear() error { +// Initialize mocks base method +func (m *MockRateLimitCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockRateLimitCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockRateLimitCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRateLimitCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRateLimitCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockRateLimitCache) Close() error { +// Update mocks base method +func (m *MockRateLimitCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockRateLimitCacheMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRateLimitCache)(nil).Close)) -} - -// GetRateLimitRules mocks base method. -func (m *MockRateLimitCache) GetRateLimitRules(serviceKey model.ServiceKey) ([]*model.RateLimit, string) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRateLimitRules", serviceKey) - ret0, _ := ret[0].([]*model.RateLimit) - ret1, _ := ret[1].(string) - return ret0, ret1 -} - -// GetRateLimitRules indicates an expected call of GetRateLimitRules. -func (mr *MockRateLimitCacheMockRecorder) GetRateLimitRules(serviceKey interface{}) *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockRateLimitCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitRules", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitRules), serviceKey) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRateLimitCache)(nil).Update)) } -// GetRateLimitsCount mocks base method. -func (m *MockRateLimitCache) GetRateLimitsCount() int { +// Clear mocks base method +func (m *MockRateLimitCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRateLimitsCount") - ret0, _ := ret[0].(int) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetRateLimitsCount indicates an expected call of GetRateLimitsCount. -func (mr *MockRateLimitCacheMockRecorder) GetRateLimitsCount() *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockRateLimitCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitsCount", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitsCount)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRateLimitCache)(nil).Clear)) } -// GetRule mocks base method. -func (m *MockRateLimitCache) GetRule(id string) *model.RateLimit { +// Name mocks base method +func (m *MockRateLimitCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRule", id) - ret0, _ := ret[0].(*model.RateLimit) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetRule indicates an expected call of GetRule. -func (mr *MockRateLimitCacheMockRecorder) GetRule(id interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockRateLimitCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockRateLimitCache)(nil).GetRule), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRateLimitCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockRateLimitCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockRateLimitCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockRateLimitCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockRateLimitCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRateLimitCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRateLimitCache)(nil).Close)) } -// IteratorRateLimit mocks base method. +// IteratorRateLimit mocks base method func (m *MockRateLimitCache) IteratorRateLimit(rateLimitIterProc api.RateLimitIterProc) { m.ctrl.T.Helper() m.ctrl.Call(m, "IteratorRateLimit", rateLimitIterProc) } -// IteratorRateLimit indicates an expected call of IteratorRateLimit. +// IteratorRateLimit indicates an expected call of IteratorRateLimit func (mr *MockRateLimitCacheMockRecorder) IteratorRateLimit(rateLimitIterProc interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorRateLimit", reflect.TypeOf((*MockRateLimitCache)(nil).IteratorRateLimit), rateLimitIterProc) } -// Name mocks base method. -func (m *MockRateLimitCache) Name() string { +// GetRateLimitRules mocks base method +func (m *MockRateLimitCache) GetRateLimitRules(serviceKey model.ServiceKey) ([]*model.RateLimit, string) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 + ret := m.ctrl.Call(m, "GetRateLimitRules", serviceKey) + ret0, _ := ret[0].([]*model.RateLimit) + ret1, _ := ret[1].(string) + return ret0, ret1 } -// Name indicates an expected call of Name. -func (mr *MockRateLimitCacheMockRecorder) Name() *gomock.Call { +// GetRateLimitRules indicates an expected call of GetRateLimitRules +func (mr *MockRateLimitCacheMockRecorder) GetRateLimitRules(serviceKey interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRateLimitCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitRules", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitRules), serviceKey) } -// QueryRateLimitRules mocks base method. +// QueryRateLimitRules mocks base method func (m *MockRateLimitCache) QueryRateLimitRules(arg0 context.Context, arg1 api.RateLimitRuleArgs) (uint32, []*model.RateLimit, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryRateLimitRules", arg0, arg1) @@ -1978,120 +1977,134 @@ func (m *MockRateLimitCache) QueryRateLimitRules(arg0 context.Context, arg1 api. return ret0, ret1, ret2 } -// QueryRateLimitRules indicates an expected call of QueryRateLimitRules. +// QueryRateLimitRules indicates an expected call of QueryRateLimitRules func (mr *MockRateLimitCacheMockRecorder) QueryRateLimitRules(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRateLimitRules", reflect.TypeOf((*MockRateLimitCache)(nil).QueryRateLimitRules), arg0, arg1) } -// Update mocks base method. -func (m *MockRateLimitCache) Update() error { +// GetRateLimitsCount mocks base method +func (m *MockRateLimitCache) GetRateLimitsCount() int { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetRateLimitsCount") + ret0, _ := ret[0].(int) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockRateLimitCacheMockRecorder) Update() *gomock.Call { +// GetRateLimitsCount indicates an expected call of GetRateLimitsCount +func (mr *MockRateLimitCacheMockRecorder) GetRateLimitsCount() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRateLimitCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitsCount", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitsCount)) +} + +// GetRule mocks base method +func (m *MockRateLimitCache) GetRule(id string) *model.RateLimit { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRule", id) + ret0, _ := ret[0].(*model.RateLimit) + return ret0 +} + +// GetRule indicates an expected call of GetRule +func (mr *MockRateLimitCacheMockRecorder) GetRule(id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockRateLimitCache)(nil).GetRule), id) } -// MockL5Cache is a mock of L5Cache interface. +// MockL5Cache is a mock of L5Cache interface type MockL5Cache struct { ctrl *gomock.Controller recorder *MockL5CacheMockRecorder } -// MockL5CacheMockRecorder is the mock recorder for MockL5Cache. +// MockL5CacheMockRecorder is the mock recorder for MockL5Cache type MockL5CacheMockRecorder struct { mock *MockL5Cache } -// NewMockL5Cache creates a new mock instance. +// NewMockL5Cache creates a new mock instance func NewMockL5Cache(ctrl *gomock.Controller) *MockL5Cache { mock := &MockL5Cache{ctrl: ctrl} mock.recorder = &MockL5CacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockL5Cache) EXPECT() *MockL5CacheMockRecorder { return m.recorder } -// CheckRouteExisted mocks base method. -func (m *MockL5Cache) CheckRouteExisted(ip, modID, cmdID uint32) bool { +// Initialize mocks base method +func (m *MockL5Cache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CheckRouteExisted", ip, modID, cmdID) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) return ret0 } -// CheckRouteExisted indicates an expected call of CheckRouteExisted. -func (mr *MockL5CacheMockRecorder) CheckRouteExisted(ip, modID, cmdID interface{}) *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockL5CacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRouteExisted", reflect.TypeOf((*MockL5Cache)(nil).CheckRouteExisted), ip, modID, cmdID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockL5Cache)(nil).Initialize), c) } -// Clear mocks base method. -func (m *MockL5Cache) Clear() error { +// Update mocks base method +func (m *MockL5Cache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockL5CacheMockRecorder) Clear() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockL5CacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockL5Cache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockL5Cache)(nil).Update)) } -// Close mocks base method. -func (m *MockL5Cache) Close() error { +// Clear mocks base method +func (m *MockL5Cache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Clear") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockL5CacheMockRecorder) Close() *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockL5CacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockL5Cache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockL5Cache)(nil).Clear)) } -// GetIPConfig mocks base method. -func (m *MockL5Cache) GetIPConfig(ip uint32) *model.IPConfig { +// Name mocks base method +func (m *MockL5Cache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIPConfig", ip) - ret0, _ := ret[0].(*model.IPConfig) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetIPConfig indicates an expected call of GetIPConfig. -func (mr *MockL5CacheMockRecorder) GetIPConfig(ip interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockL5CacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIPConfig", reflect.TypeOf((*MockL5Cache)(nil).GetIPConfig), ip) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockL5Cache)(nil).Name)) } -// GetPolicy mocks base method. -func (m *MockL5Cache) GetPolicy(modID uint32) *model.Policy { +// Close mocks base method +func (m *MockL5Cache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPolicy", modID) - ret0, _ := ret[0].(*model.Policy) + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) return ret0 } -// GetPolicy indicates an expected call of GetPolicy. -func (mr *MockL5CacheMockRecorder) GetPolicy(modID interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockL5CacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicy", reflect.TypeOf((*MockL5Cache)(nil).GetPolicy), modID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockL5Cache)(nil).Close)) } -// GetRouteByIP mocks base method. +// GetRouteByIP mocks base method func (m *MockL5Cache) GetRouteByIP(ip uint32) []*model.Route { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRouteByIP", ip) @@ -2099,176 +2112,162 @@ func (m *MockL5Cache) GetRouteByIP(ip uint32) []*model.Route { return ret0 } -// GetRouteByIP indicates an expected call of GetRouteByIP. +// GetRouteByIP indicates an expected call of GetRouteByIP func (mr *MockL5CacheMockRecorder) GetRouteByIP(ip interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouteByIP", reflect.TypeOf((*MockL5Cache)(nil).GetRouteByIP), ip) } -// GetSection mocks base method. -func (m *MockL5Cache) GetSection(modeID uint32) []*model.Section { +// CheckRouteExisted mocks base method +func (m *MockL5Cache) CheckRouteExisted(ip, modID, cmdID uint32) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSection", modeID) - ret0, _ := ret[0].([]*model.Section) + ret := m.ctrl.Call(m, "CheckRouteExisted", ip, modID, cmdID) + ret0, _ := ret[0].(bool) return ret0 } -// GetSection indicates an expected call of GetSection. -func (mr *MockL5CacheMockRecorder) GetSection(modeID interface{}) *gomock.Call { +// CheckRouteExisted indicates an expected call of CheckRouteExisted +func (mr *MockL5CacheMockRecorder) CheckRouteExisted(ip, modID, cmdID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSection", reflect.TypeOf((*MockL5Cache)(nil).GetSection), modeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRouteExisted", reflect.TypeOf((*MockL5Cache)(nil).CheckRouteExisted), ip, modID, cmdID) } -// Initialize mocks base method. -func (m *MockL5Cache) Initialize(c map[string]interface{}) error { +// GetPolicy mocks base method +func (m *MockL5Cache) GetPolicy(modID uint32) *model.Policy { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetPolicy", modID) + ret0, _ := ret[0].(*model.Policy) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockL5CacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// GetPolicy indicates an expected call of GetPolicy +func (mr *MockL5CacheMockRecorder) GetPolicy(modID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockL5Cache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicy", reflect.TypeOf((*MockL5Cache)(nil).GetPolicy), modID) } -// Name mocks base method. -func (m *MockL5Cache) Name() string { +// GetSection mocks base method +func (m *MockL5Cache) GetSection(modeID uint32) []*model.Section { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetSection", modeID) + ret0, _ := ret[0].([]*model.Section) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockL5CacheMockRecorder) Name() *gomock.Call { +// GetSection indicates an expected call of GetSection +func (mr *MockL5CacheMockRecorder) GetSection(modeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockL5Cache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSection", reflect.TypeOf((*MockL5Cache)(nil).GetSection), modeID) } -// Update mocks base method. -func (m *MockL5Cache) Update() error { +// GetIPConfig mocks base method +func (m *MockL5Cache) GetIPConfig(ip uint32) *model.IPConfig { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetIPConfig", ip) + ret0, _ := ret[0].(*model.IPConfig) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockL5CacheMockRecorder) Update() *gomock.Call { +// GetIPConfig indicates an expected call of GetIPConfig +func (mr *MockL5CacheMockRecorder) GetIPConfig(ip interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockL5Cache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIPConfig", reflect.TypeOf((*MockL5Cache)(nil).GetIPConfig), ip) } -// MockCircuitBreakerCache is a mock of CircuitBreakerCache interface. +// MockCircuitBreakerCache is a mock of CircuitBreakerCache interface type MockCircuitBreakerCache struct { ctrl *gomock.Controller recorder *MockCircuitBreakerCacheMockRecorder } -// MockCircuitBreakerCacheMockRecorder is the mock recorder for MockCircuitBreakerCache. +// MockCircuitBreakerCacheMockRecorder is the mock recorder for MockCircuitBreakerCache type MockCircuitBreakerCacheMockRecorder struct { mock *MockCircuitBreakerCache } -// NewMockCircuitBreakerCache creates a new mock instance. +// NewMockCircuitBreakerCache creates a new mock instance func NewMockCircuitBreakerCache(ctrl *gomock.Controller) *MockCircuitBreakerCache { mock := &MockCircuitBreakerCache{ctrl: ctrl} mock.recorder = &MockCircuitBreakerCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockCircuitBreakerCache) EXPECT() *MockCircuitBreakerCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockCircuitBreakerCache) Clear() error { +// Initialize mocks base method +func (m *MockCircuitBreakerCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockCircuitBreakerCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockCircuitBreakerCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockCircuitBreakerCache) Close() error { +// Update mocks base method +func (m *MockCircuitBreakerCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockCircuitBreakerCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockCircuitBreakerCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Update)) } -// GetCircuitBreakerConfig mocks base method. -func (m *MockCircuitBreakerCache) GetCircuitBreakerConfig(svcName, namespace string) *model.ServiceWithCircuitBreakerRules { +// Clear mocks base method +func (m *MockCircuitBreakerCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCircuitBreakerConfig", svcName, namespace) - ret0, _ := ret[0].(*model.ServiceWithCircuitBreakerRules) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetCircuitBreakerConfig indicates an expected call of GetCircuitBreakerConfig. -func (mr *MockCircuitBreakerCacheMockRecorder) GetCircuitBreakerConfig(svcName, namespace interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockCircuitBreakerCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCircuitBreakerConfig", reflect.TypeOf((*MockCircuitBreakerCache)(nil).GetCircuitBreakerConfig), svcName, namespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Clear)) } -// GetRule mocks base method. -func (m *MockCircuitBreakerCache) GetRule(id string) *model.CircuitBreakerRule { +// Name mocks base method +func (m *MockCircuitBreakerCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRule", id) - ret0, _ := ret[0].(*model.CircuitBreakerRule) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetRule indicates an expected call of GetRule. -func (mr *MockCircuitBreakerCacheMockRecorder) GetRule(id interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockCircuitBreakerCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockCircuitBreakerCache)(nil).GetRule), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockCircuitBreakerCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockCircuitBreakerCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockCircuitBreakerCacheMockRecorder) Initialize(c interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Initialize), c) -} - -// Name mocks base method. -func (m *MockCircuitBreakerCache) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockCircuitBreakerCacheMockRecorder) Name() *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockCircuitBreakerCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Close)) } -// Query mocks base method. +// Query mocks base method func (m *MockCircuitBreakerCache) Query(arg0 context.Context, arg1 *api.CircuitBreakerRuleArgs) (uint32, []*model.CircuitBreakerRule, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -2278,50 +2277,92 @@ func (m *MockCircuitBreakerCache) Query(arg0 context.Context, arg1 *api.CircuitB return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockCircuitBreakerCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockCircuitBreakerCache) Update() error { +// GetCircuitBreakerConfig mocks base method +func (m *MockCircuitBreakerCache) GetCircuitBreakerConfig(svcName, namespace string) *model.ServiceWithCircuitBreakerRules { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetCircuitBreakerConfig", svcName, namespace) + ret0, _ := ret[0].(*model.ServiceWithCircuitBreakerRules) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockCircuitBreakerCacheMockRecorder) Update() *gomock.Call { +// GetCircuitBreakerConfig indicates an expected call of GetCircuitBreakerConfig +func (mr *MockCircuitBreakerCacheMockRecorder) GetCircuitBreakerConfig(svcName, namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCircuitBreakerConfig", reflect.TypeOf((*MockCircuitBreakerCache)(nil).GetCircuitBreakerConfig), svcName, namespace) +} + +// GetRule mocks base method +func (m *MockCircuitBreakerCache) GetRule(id string) *model.CircuitBreakerRule { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRule", id) + ret0, _ := ret[0].(*model.CircuitBreakerRule) + return ret0 +} + +// GetRule indicates an expected call of GetRule +func (mr *MockCircuitBreakerCacheMockRecorder) GetRule(id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRule", reflect.TypeOf((*MockCircuitBreakerCache)(nil).GetRule), id) } -// MockConfigGroupCache is a mock of ConfigGroupCache interface. +// MockConfigGroupCache is a mock of ConfigGroupCache interface type MockConfigGroupCache struct { ctrl *gomock.Controller recorder *MockConfigGroupCacheMockRecorder } -// MockConfigGroupCacheMockRecorder is the mock recorder for MockConfigGroupCache. +// MockConfigGroupCacheMockRecorder is the mock recorder for MockConfigGroupCache type MockConfigGroupCacheMockRecorder struct { mock *MockConfigGroupCache } -// NewMockConfigGroupCache creates a new mock instance. +// NewMockConfigGroupCache creates a new mock instance func NewMockConfigGroupCache(ctrl *gomock.Controller) *MockConfigGroupCache { mock := &MockConfigGroupCache{ctrl: ctrl} mock.recorder = &MockConfigGroupCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockConfigGroupCache) EXPECT() *MockConfigGroupCacheMockRecorder { return m.recorder } -// Clear mocks base method. +// Initialize mocks base method +func (m *MockConfigGroupCache) Initialize(c map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialize indicates an expected call of Initialize +func (mr *MockConfigGroupCacheMockRecorder) Initialize(c interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigGroupCache)(nil).Initialize), c) +} + +// Update mocks base method +func (m *MockConfigGroupCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (mr *MockConfigGroupCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigGroupCache)(nil).Update)) +} + +// Clear mocks base method func (m *MockConfigGroupCache) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -2329,41 +2370,41 @@ func (m *MockConfigGroupCache) Clear() error { return ret0 } -// Clear indicates an expected call of Clear. +// Clear indicates an expected call of Clear func (mr *MockConfigGroupCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockConfigGroupCache)(nil).Clear)) } -// Close mocks base method. -func (m *MockConfigGroupCache) Close() error { +// Name mocks base method +func (m *MockConfigGroupCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockConfigGroupCacheMockRecorder) Close() *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockConfigGroupCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConfigGroupCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigGroupCache)(nil).Name)) } -// GetGroupByID mocks base method. -func (m *MockConfigGroupCache) GetGroupByID(id uint64) *model.ConfigFileGroup { +// Close mocks base method +func (m *MockConfigGroupCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGroupByID", id) - ret0, _ := ret[0].(*model.ConfigFileGroup) + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) return ret0 } -// GetGroupByID indicates an expected call of GetGroupByID. -func (mr *MockConfigGroupCacheMockRecorder) GetGroupByID(id interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockConfigGroupCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByID", reflect.TypeOf((*MockConfigGroupCache)(nil).GetGroupByID), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConfigGroupCache)(nil).Close)) } -// GetGroupByName mocks base method. +// GetGroupByName mocks base method func (m *MockConfigGroupCache) GetGroupByName(namespace, name string) *model.ConfigFileGroup { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetGroupByName", namespace, name) @@ -2371,27 +2412,27 @@ func (m *MockConfigGroupCache) GetGroupByName(namespace, name string) *model.Con return ret0 } -// GetGroupByName indicates an expected call of GetGroupByName. +// GetGroupByName indicates an expected call of GetGroupByName func (mr *MockConfigGroupCacheMockRecorder) GetGroupByName(namespace, name interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByName", reflect.TypeOf((*MockConfigGroupCache)(nil).GetGroupByName), namespace, name) } -// Initialize mocks base method. -func (m *MockConfigGroupCache) Initialize(c map[string]interface{}) error { +// GetGroupByID mocks base method +func (m *MockConfigGroupCache) GetGroupByID(id uint64) *model.ConfigFileGroup { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetGroupByID", id) + ret0, _ := ret[0].(*model.ConfigFileGroup) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockConfigGroupCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// GetGroupByID indicates an expected call of GetGroupByID +func (mr *MockConfigGroupCacheMockRecorder) GetGroupByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigGroupCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByID", reflect.TypeOf((*MockConfigGroupCache)(nil).GetGroupByID), id) } -// ListGroups mocks base method. +// ListGroups mocks base method func (m *MockConfigGroupCache) ListGroups(namespace string) ([]*model.ConfigFileGroup, string) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListGroups", namespace) @@ -2400,27 +2441,13 @@ func (m *MockConfigGroupCache) ListGroups(namespace string) ([]*model.ConfigFile return ret0, ret1 } -// ListGroups indicates an expected call of ListGroups. -func (mr *MockConfigGroupCacheMockRecorder) ListGroups(namespace interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroups", reflect.TypeOf((*MockConfigGroupCache)(nil).ListGroups), namespace) -} - -// Name mocks base method. -func (m *MockConfigGroupCache) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockConfigGroupCacheMockRecorder) Name() *gomock.Call { +// ListGroups indicates an expected call of ListGroups +func (mr *MockConfigGroupCacheMockRecorder) ListGroups(namespace interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigGroupCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroups", reflect.TypeOf((*MockConfigGroupCache)(nil).ListGroups), namespace) } -// Query mocks base method. +// Query mocks base method func (m *MockConfigGroupCache) Query(args *api.ConfigGroupArgs) (uint32, []*model.ConfigFileGroup, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", args) @@ -2430,106 +2457,106 @@ func (m *MockConfigGroupCache) Query(args *api.ConfigGroupArgs) (uint32, []*mode return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockConfigGroupCacheMockRecorder) Query(args interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockConfigGroupCache)(nil).Query), args) } -// Update mocks base method. -func (m *MockConfigGroupCache) Update() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) - return ret0 -} - -// Update indicates an expected call of Update. -func (mr *MockConfigGroupCacheMockRecorder) Update() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigGroupCache)(nil).Update)) -} - -// MockConfigFileCache is a mock of ConfigFileCache interface. +// MockConfigFileCache is a mock of ConfigFileCache interface type MockConfigFileCache struct { ctrl *gomock.Controller recorder *MockConfigFileCacheMockRecorder } -// MockConfigFileCacheMockRecorder is the mock recorder for MockConfigFileCache. +// MockConfigFileCacheMockRecorder is the mock recorder for MockConfigFileCache type MockConfigFileCacheMockRecorder struct { mock *MockConfigFileCache } -// NewMockConfigFileCache creates a new mock instance. +// NewMockConfigFileCache creates a new mock instance func NewMockConfigFileCache(ctrl *gomock.Controller) *MockConfigFileCache { mock := &MockConfigFileCache{ctrl: ctrl} mock.recorder = &MockConfigFileCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockConfigFileCache) EXPECT() *MockConfigFileCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockConfigFileCache) Clear() error { +// Initialize mocks base method +func (m *MockConfigFileCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockConfigFileCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockConfigFileCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockConfigFileCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigFileCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockConfigFileCache) Close() error { +// Update mocks base method +func (m *MockConfigFileCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockConfigFileCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockConfigFileCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConfigFileCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigFileCache)(nil).Update)) } -// GetActiveGrayRelease mocks base method. -func (m *MockConfigFileCache) GetActiveGrayRelease(namespace, group, fileName string) *model.ConfigFileRelease { +// Clear mocks base method +func (m *MockConfigFileCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetActiveGrayRelease", namespace, group, fileName) - ret0, _ := ret[0].(*model.ConfigFileRelease) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetActiveGrayRelease indicates an expected call of GetActiveGrayRelease. -func (mr *MockConfigFileCacheMockRecorder) GetActiveGrayRelease(namespace, group, fileName interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockConfigFileCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveGrayRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetActiveGrayRelease), namespace, group, fileName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockConfigFileCache)(nil).Clear)) } -// GetActiveRelease mocks base method. -func (m *MockConfigFileCache) GetActiveRelease(namespace, group, fileName string) *model.ConfigFileRelease { +// Name mocks base method +func (m *MockConfigFileCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetActiveRelease", namespace, group, fileName) - ret0, _ := ret[0].(*model.ConfigFileRelease) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetActiveRelease indicates an expected call of GetActiveRelease. -func (mr *MockConfigFileCacheMockRecorder) GetActiveRelease(namespace, group, fileName interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockConfigFileCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetActiveRelease), namespace, group, fileName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigFileCache)(nil).Name)) +} + +// Close mocks base method +func (m *MockConfigFileCache) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close +func (mr *MockConfigFileCacheMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConfigFileCache)(nil).Close)) } -// GetGroupActiveReleases mocks base method. +// GetGroupActiveReleases mocks base method func (m *MockConfigFileCache) GetGroupActiveReleases(namespace, group string) ([]*model.ConfigFileRelease, string) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetGroupActiveReleases", namespace, group) @@ -2538,55 +2565,55 @@ func (m *MockConfigFileCache) GetGroupActiveReleases(namespace, group string) ([ return ret0, ret1 } -// GetGroupActiveReleases indicates an expected call of GetGroupActiveReleases. +// GetGroupActiveReleases indicates an expected call of GetGroupActiveReleases func (mr *MockConfigFileCacheMockRecorder) GetGroupActiveReleases(namespace, group interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupActiveReleases", reflect.TypeOf((*MockConfigFileCache)(nil).GetGroupActiveReleases), namespace, group) } -// GetRelease mocks base method. -func (m *MockConfigFileCache) GetRelease(key model.ConfigFileReleaseKey) *model.ConfigFileRelease { +// GetActiveRelease mocks base method +func (m *MockConfigFileCache) GetActiveRelease(namespace, group, fileName string) *model.ConfigFileRelease { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRelease", key) + ret := m.ctrl.Call(m, "GetActiveRelease", namespace, group, fileName) ret0, _ := ret[0].(*model.ConfigFileRelease) return ret0 } -// GetRelease indicates an expected call of GetRelease. -func (mr *MockConfigFileCacheMockRecorder) GetRelease(key interface{}) *gomock.Call { +// GetActiveRelease indicates an expected call of GetActiveRelease +func (mr *MockConfigFileCacheMockRecorder) GetActiveRelease(namespace, group, fileName interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetRelease), key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetActiveRelease), namespace, group, fileName) } -// Initialize mocks base method. -func (m *MockConfigFileCache) Initialize(c map[string]interface{}) error { +// GetActiveGrayRelease mocks base method +func (m *MockConfigFileCache) GetActiveGrayRelease(namespace, group, fileName string) *model.ConfigFileRelease { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetActiveGrayRelease", namespace, group, fileName) + ret0, _ := ret[0].(*model.ConfigFileRelease) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockConfigFileCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// GetActiveGrayRelease indicates an expected call of GetActiveGrayRelease +func (mr *MockConfigFileCacheMockRecorder) GetActiveGrayRelease(namespace, group, fileName interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigFileCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveGrayRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetActiveGrayRelease), namespace, group, fileName) } -// Name mocks base method. -func (m *MockConfigFileCache) Name() string { +// GetRelease mocks base method +func (m *MockConfigFileCache) GetRelease(key model.ConfigFileReleaseKey) *model.ConfigFileRelease { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetRelease", key) + ret0, _ := ret[0].(*model.ConfigFileRelease) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockConfigFileCacheMockRecorder) Name() *gomock.Call { +// GetRelease indicates an expected call of GetRelease +func (mr *MockConfigFileCacheMockRecorder) GetRelease(key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigFileCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetRelease), key) } -// QueryReleases mocks base method. +// QueryReleases mocks base method func (m *MockConfigFileCache) QueryReleases(args *api.ConfigReleaseArgs) (uint32, []*model.SimpleConfigFileRelease, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryReleases", args) @@ -2596,50 +2623,64 @@ func (m *MockConfigFileCache) QueryReleases(args *api.ConfigReleaseArgs) (uint32 return ret0, ret1, ret2 } -// QueryReleases indicates an expected call of QueryReleases. +// QueryReleases indicates an expected call of QueryReleases func (mr *MockConfigFileCacheMockRecorder) QueryReleases(args interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryReleases", reflect.TypeOf((*MockConfigFileCache)(nil).QueryReleases), args) } -// Update mocks base method. -func (m *MockConfigFileCache) Update() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) - return ret0 -} - -// Update indicates an expected call of Update. -func (mr *MockConfigFileCacheMockRecorder) Update() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigFileCache)(nil).Update)) -} - -// MockUserCache is a mock of UserCache interface. +// MockUserCache is a mock of UserCache interface type MockUserCache struct { ctrl *gomock.Controller recorder *MockUserCacheMockRecorder } -// MockUserCacheMockRecorder is the mock recorder for MockUserCache. +// MockUserCacheMockRecorder is the mock recorder for MockUserCache type MockUserCacheMockRecorder struct { mock *MockUserCache } -// NewMockUserCache creates a new mock instance. +// NewMockUserCache creates a new mock instance func NewMockUserCache(ctrl *gomock.Controller) *MockUserCache { mock := &MockUserCache{ctrl: ctrl} mock.recorder = &MockUserCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockUserCache) EXPECT() *MockUserCacheMockRecorder { return m.recorder } -// Clear mocks base method. +// Initialize mocks base method +func (m *MockUserCache) Initialize(c map[string]interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialize", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialize indicates an expected call of Initialize +func (mr *MockUserCacheMockRecorder) Initialize(c interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockUserCache)(nil).Initialize), c) +} + +// Update mocks base method +func (m *MockUserCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 +} + +// Update indicates an expected call of Update +func (mr *MockUserCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserCache)(nil).Update)) +} + +// Clear mocks base method func (m *MockUserCache) Clear() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Clear") @@ -2647,13 +2688,27 @@ func (m *MockUserCache) Clear() error { return ret0 } -// Clear indicates an expected call of Clear. +// Clear indicates an expected call of Clear func (mr *MockUserCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockUserCache)(nil).Clear)) } -// Close mocks base method. +// Name mocks base method +func (m *MockUserCache) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name +func (mr *MockUserCacheMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockUserCache)(nil).Name)) +} + +// Close mocks base method func (m *MockUserCache) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -2661,13 +2716,13 @@ func (m *MockUserCache) Close() error { return ret0 } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockUserCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUserCache)(nil).Close)) } -// GetAdmin mocks base method. +// GetAdmin mocks base method func (m *MockUserCache) GetAdmin() *auth.User { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAdmin") @@ -2675,27 +2730,13 @@ func (m *MockUserCache) GetAdmin() *auth.User { return ret0 } -// GetAdmin indicates an expected call of GetAdmin. +// GetAdmin indicates an expected call of GetAdmin func (mr *MockUserCacheMockRecorder) GetAdmin() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAdmin", reflect.TypeOf((*MockUserCache)(nil).GetAdmin)) } -// GetGroup mocks base method. -func (m *MockUserCache) GetGroup(id string) *auth.UserGroupDetail { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGroup", id) - ret0, _ := ret[0].(*auth.UserGroupDetail) - return ret0 -} - -// GetGroup indicates an expected call of GetGroup. -func (mr *MockUserCacheMockRecorder) GetGroup(id interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockUserCache)(nil).GetGroup), id) -} - -// GetUserByID mocks base method. +// GetUserByID mocks base method func (m *MockUserCache) GetUserByID(id string) *auth.User { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetUserByID", id) @@ -2703,13 +2744,13 @@ func (m *MockUserCache) GetUserByID(id string) *auth.User { return ret0 } -// GetUserByID indicates an expected call of GetUserByID. +// GetUserByID indicates an expected call of GetUserByID func (mr *MockUserCacheMockRecorder) GetUserByID(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByID", reflect.TypeOf((*MockUserCache)(nil).GetUserByID), id) } -// GetUserByName mocks base method. +// GetUserByName mocks base method func (m *MockUserCache) GetUserByName(name, ownerName string) *auth.User { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetUserByName", name, ownerName) @@ -2717,41 +2758,41 @@ func (m *MockUserCache) GetUserByName(name, ownerName string) *auth.User { return ret0 } -// GetUserByName indicates an expected call of GetUserByName. +// GetUserByName indicates an expected call of GetUserByName func (mr *MockUserCacheMockRecorder) GetUserByName(name, ownerName interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByName", reflect.TypeOf((*MockUserCache)(nil).GetUserByName), name, ownerName) } -// GetUserLinkGroupIds mocks base method. -func (m *MockUserCache) GetUserLinkGroupIds(id string) []string { +// GetGroup mocks base method +func (m *MockUserCache) GetGroup(id string) *auth.UserGroupDetail { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetUserLinkGroupIds", id) - ret0, _ := ret[0].([]string) + ret := m.ctrl.Call(m, "GetGroup", id) + ret0, _ := ret[0].(*auth.UserGroupDetail) return ret0 } -// GetUserLinkGroupIds indicates an expected call of GetUserLinkGroupIds. -func (mr *MockUserCacheMockRecorder) GetUserLinkGroupIds(id interface{}) *gomock.Call { +// GetGroup indicates an expected call of GetGroup +func (mr *MockUserCacheMockRecorder) GetGroup(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLinkGroupIds", reflect.TypeOf((*MockUserCache)(nil).GetUserLinkGroupIds), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockUserCache)(nil).GetGroup), id) } -// Initialize mocks base method. -func (m *MockUserCache) Initialize(c map[string]interface{}) error { +// IsUserInGroup mocks base method +func (m *MockUserCache) IsUserInGroup(userId, groupId string) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "IsUserInGroup", userId, groupId) + ret0, _ := ret[0].(bool) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockUserCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// IsUserInGroup indicates an expected call of IsUserInGroup +func (mr *MockUserCacheMockRecorder) IsUserInGroup(userId, groupId interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockUserCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUserInGroup", reflect.TypeOf((*MockUserCache)(nil).IsUserInGroup), userId, groupId) } -// IsOwner mocks base method. +// IsOwner mocks base method func (m *MockUserCache) IsOwner(id string) bool { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsOwner", id) @@ -2759,41 +2800,43 @@ func (m *MockUserCache) IsOwner(id string) bool { return ret0 } -// IsOwner indicates an expected call of IsOwner. +// IsOwner indicates an expected call of IsOwner func (mr *MockUserCacheMockRecorder) IsOwner(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOwner", reflect.TypeOf((*MockUserCache)(nil).IsOwner), id) } -// IsUserInGroup mocks base method. -func (m *MockUserCache) IsUserInGroup(userId, groupId string) bool { +// GetUserLinkGroupIds mocks base method +func (m *MockUserCache) GetUserLinkGroupIds(id string) []string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsUserInGroup", userId, groupId) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "GetUserLinkGroupIds", id) + ret0, _ := ret[0].([]string) return ret0 } -// IsUserInGroup indicates an expected call of IsUserInGroup. -func (mr *MockUserCacheMockRecorder) IsUserInGroup(userId, groupId interface{}) *gomock.Call { +// GetUserLinkGroupIds indicates an expected call of GetUserLinkGroupIds +func (mr *MockUserCacheMockRecorder) GetUserLinkGroupIds(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUserInGroup", reflect.TypeOf((*MockUserCache)(nil).IsUserInGroup), userId, groupId) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLinkGroupIds", reflect.TypeOf((*MockUserCache)(nil).GetUserLinkGroupIds), id) } -// Name mocks base method. -func (m *MockUserCache) Name() string { +// QueryUsers mocks base method +func (m *MockUserCache) QueryUsers(arg0 context.Context, arg1 api.UserSearchArgs) (uint32, []*auth.User, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 + ret := m.ctrl.Call(m, "QueryUsers", arg0, arg1) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].([]*auth.User) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// Name indicates an expected call of Name. -func (mr *MockUserCacheMockRecorder) Name() *gomock.Call { +// QueryUsers indicates an expected call of QueryUsers +func (mr *MockUserCacheMockRecorder) QueryUsers(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockUserCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUsers", reflect.TypeOf((*MockUserCache)(nil).QueryUsers), arg0, arg1) } -// QueryUserGroups mocks base method. +// QueryUserGroups mocks base method func (m *MockUserCache) QueryUserGroups(arg0 context.Context, arg1 api.UserGroupSearchArgs) (uint32, []*auth.UserGroupDetail, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "QueryUserGroups", arg0, arg1) @@ -2803,80 +2846,92 @@ func (m *MockUserCache) QueryUserGroups(arg0 context.Context, arg1 api.UserGroup return ret0, ret1, ret2 } -// QueryUserGroups indicates an expected call of QueryUserGroups. +// QueryUserGroups indicates an expected call of QueryUserGroups func (mr *MockUserCacheMockRecorder) QueryUserGroups(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUserGroups", reflect.TypeOf((*MockUserCache)(nil).QueryUserGroups), arg0, arg1) } -// QueryUsers mocks base method. -func (m *MockUserCache) QueryUsers(arg0 context.Context, arg1 api.UserSearchArgs) (uint32, []*auth.User, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryUsers", arg0, arg1) - ret0, _ := ret[0].(uint32) - ret1, _ := ret[1].([]*auth.User) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 +// MockStrategyCache is a mock of StrategyCache interface +type MockStrategyCache struct { + ctrl *gomock.Controller + recorder *MockStrategyCacheMockRecorder } -// QueryUsers indicates an expected call of QueryUsers. -func (mr *MockUserCacheMockRecorder) QueryUsers(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryUsers", reflect.TypeOf((*MockUserCache)(nil).QueryUsers), arg0, arg1) +// MockStrategyCacheMockRecorder is the mock recorder for MockStrategyCache +type MockStrategyCacheMockRecorder struct { + mock *MockStrategyCache } -// Update mocks base method. -func (m *MockUserCache) Update() error { +// NewMockStrategyCache creates a new mock instance +func NewMockStrategyCache(ctrl *gomock.Controller) *MockStrategyCache { + mock := &MockStrategyCache{ctrl: ctrl} + mock.recorder = &MockStrategyCacheMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockStrategyCache) EXPECT() *MockStrategyCacheMockRecorder { + return m.recorder +} + +// Initialize mocks base method +func (m *MockStrategyCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockUserCacheMockRecorder) Update() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockStrategyCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockStrategyCache)(nil).Initialize), c) } -// MockStrategyCache is a mock of StrategyCache interface. -type MockStrategyCache struct { - ctrl *gomock.Controller - recorder *MockStrategyCacheMockRecorder +// Update mocks base method +func (m *MockStrategyCache) Update() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update") + ret0, _ := ret[0].(error) + return ret0 } -// MockStrategyCacheMockRecorder is the mock recorder for MockStrategyCache. -type MockStrategyCacheMockRecorder struct { - mock *MockStrategyCache +// Update indicates an expected call of Update +func (mr *MockStrategyCacheMockRecorder) Update() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStrategyCache)(nil).Update)) } -// NewMockStrategyCache creates a new mock instance. -func NewMockStrategyCache(ctrl *gomock.Controller) *MockStrategyCache { - mock := &MockStrategyCache{ctrl: ctrl} - mock.recorder = &MockStrategyCacheMockRecorder{mock} - return mock +// Clear mocks base method +func (m *MockStrategyCache) Clear() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) + return ret0 } -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStrategyCache) EXPECT() *MockStrategyCacheMockRecorder { - return m.recorder +// Clear indicates an expected call of Clear +func (mr *MockStrategyCacheMockRecorder) Clear() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockStrategyCache)(nil).Clear)) } -// Clear mocks base method. -func (m *MockStrategyCache) Clear() error { +// Name mocks base method +func (m *MockStrategyCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockStrategyCacheMockRecorder) Clear() *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockStrategyCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockStrategyCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockStrategyCache)(nil).Name)) } -// Close mocks base method. +// Close mocks base method func (m *MockStrategyCache) Close() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") @@ -2884,13 +2939,13 @@ func (m *MockStrategyCache) Close() error { return ret0 } -// Close indicates an expected call of Close. +// Close indicates an expected call of Close func (mr *MockStrategyCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStrategyCache)(nil).Close)) } -// GetPolicyRule mocks base method. +// GetPolicyRule mocks base method func (m *MockStrategyCache) GetPolicyRule(id string) *auth.StrategyDetail { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPolicyRule", id) @@ -2898,13 +2953,13 @@ func (m *MockStrategyCache) GetPolicyRule(id string) *auth.StrategyDetail { return ret0 } -// GetPolicyRule indicates an expected call of GetPolicyRule. +// GetPolicyRule indicates an expected call of GetPolicyRule func (mr *MockStrategyCacheMockRecorder) GetPolicyRule(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyRule", reflect.TypeOf((*MockStrategyCache)(nil).GetPolicyRule), id) } -// GetPrincipalPolicies mocks base method. +// GetPrincipalPolicies mocks base method func (m *MockStrategyCache) GetPrincipalPolicies(effect string, p auth.Principal) []*auth.StrategyDetail { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPrincipalPolicies", effect, p) @@ -2912,55 +2967,27 @@ func (m *MockStrategyCache) GetPrincipalPolicies(effect string, p auth.Principal return ret0 } -// GetPrincipalPolicies indicates an expected call of GetPrincipalPolicies. +// GetPrincipalPolicies indicates an expected call of GetPrincipalPolicies func (mr *MockStrategyCacheMockRecorder) GetPrincipalPolicies(effect, p interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrincipalPolicies", reflect.TypeOf((*MockStrategyCache)(nil).GetPrincipalPolicies), effect, p) } -// Hint mocks base method. -func (m *MockStrategyCache) Hint(p auth.Principal, r *auth.ResourceEntry) security.AuthAction { +// Hint mocks base method +func (m *MockStrategyCache) Hint(ctx context.Context, p auth.Principal, r *auth.ResourceEntry) security.AuthAction { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Hint", p, r) + ret := m.ctrl.Call(m, "Hint", ctx, p, r) ret0, _ := ret[0].(security.AuthAction) return ret0 } -// Hint indicates an expected call of Hint. -func (mr *MockStrategyCacheMockRecorder) Hint(p, r interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hint", reflect.TypeOf((*MockStrategyCache)(nil).Hint), p, r) -} - -// Initialize mocks base method. -func (m *MockStrategyCache) Initialize(c map[string]interface{}) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) - ret0, _ := ret[0].(error) - return ret0 -} - -// Initialize indicates an expected call of Initialize. -func (mr *MockStrategyCacheMockRecorder) Initialize(c interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockStrategyCache)(nil).Initialize), c) -} - -// Name mocks base method. -func (m *MockStrategyCache) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockStrategyCacheMockRecorder) Name() *gomock.Call { +// Hint indicates an expected call of Hint +func (mr *MockStrategyCacheMockRecorder) Hint(ctx, p, r interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockStrategyCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hint", reflect.TypeOf((*MockStrategyCache)(nil).Hint), ctx, p, r) } -// Query mocks base method. +// Query mocks base method func (m *MockStrategyCache) Query(arg0 context.Context, arg1 api.PolicySearchArgs) (uint32, []*auth.StrategyDetail, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -2970,134 +2997,120 @@ func (m *MockStrategyCache) Query(arg0 context.Context, arg1 api.PolicySearchArg return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockStrategyCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStrategyCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockStrategyCache) Update() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) - return ret0 -} - -// Update indicates an expected call of Update. -func (mr *MockStrategyCacheMockRecorder) Update() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStrategyCache)(nil).Update)) -} - -// MockRoleCache is a mock of RoleCache interface. +// MockRoleCache is a mock of RoleCache interface type MockRoleCache struct { ctrl *gomock.Controller recorder *MockRoleCacheMockRecorder } -// MockRoleCacheMockRecorder is the mock recorder for MockRoleCache. +// MockRoleCacheMockRecorder is the mock recorder for MockRoleCache type MockRoleCacheMockRecorder struct { mock *MockRoleCache } -// NewMockRoleCache creates a new mock instance. +// NewMockRoleCache creates a new mock instance func NewMockRoleCache(ctrl *gomock.Controller) *MockRoleCache { mock := &MockRoleCache{ctrl: ctrl} mock.recorder = &MockRoleCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockRoleCache) EXPECT() *MockRoleCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockRoleCache) Clear() error { +// Initialize mocks base method +func (m *MockRoleCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockRoleCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockRoleCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRoleCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRoleCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockRoleCache) Close() error { +// Update mocks base method +func (m *MockRoleCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockRoleCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockRoleCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRoleCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoleCache)(nil).Update)) } -// GetPrincipalRoles mocks base method. -func (m *MockRoleCache) GetPrincipalRoles(arg0 auth.Principal) []*auth.Role { +// Clear mocks base method +func (m *MockRoleCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPrincipalRoles", arg0) - ret0, _ := ret[0].([]*auth.Role) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetPrincipalRoles indicates an expected call of GetPrincipalRoles. -func (mr *MockRoleCacheMockRecorder) GetPrincipalRoles(arg0 interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockRoleCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrincipalRoles", reflect.TypeOf((*MockRoleCache)(nil).GetPrincipalRoles), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRoleCache)(nil).Clear)) } -// GetRole mocks base method. -func (m *MockRoleCache) GetRole(id string) *auth.Role { +// Name mocks base method +func (m *MockRoleCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRole", id) - ret0, _ := ret[0].(*auth.Role) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// GetRole indicates an expected call of GetRole. -func (mr *MockRoleCacheMockRecorder) GetRole(id interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockRoleCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleCache)(nil).GetRole), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRoleCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockRoleCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockRoleCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockRoleCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockRoleCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRoleCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRoleCache)(nil).Close)) } -// Name mocks base method. -func (m *MockRoleCache) Name() string { +// GetRole mocks base method +func (m *MockRoleCache) GetRole(id string) *auth.Role { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetRole", id) + ret0, _ := ret[0].(*auth.Role) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockRoleCacheMockRecorder) Name() *gomock.Call { +// GetRole indicates an expected call of GetRole +func (mr *MockRoleCacheMockRecorder) GetRole(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRoleCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleCache)(nil).GetRole), id) } -// Query mocks base method. +// Query mocks base method func (m *MockRoleCache) Query(arg0 context.Context, arg1 api.RoleSearchArgs) (uint32, []*auth.Role, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Query", arg0, arg1) @@ -3107,278 +3120,278 @@ func (m *MockRoleCache) Query(arg0 context.Context, arg1 api.RoleSearchArgs) (ui return ret0, ret1, ret2 } -// Query indicates an expected call of Query. +// Query indicates an expected call of Query func (mr *MockRoleCacheMockRecorder) Query(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockRoleCache)(nil).Query), arg0, arg1) } -// Update mocks base method. -func (m *MockRoleCache) Update() error { +// GetPrincipalRoles mocks base method +func (m *MockRoleCache) GetPrincipalRoles(arg0 auth.Principal) []*auth.Role { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "GetPrincipalRoles", arg0) + ret0, _ := ret[0].([]*auth.Role) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockRoleCacheMockRecorder) Update() *gomock.Call { +// GetPrincipalRoles indicates an expected call of GetPrincipalRoles +func (mr *MockRoleCacheMockRecorder) GetPrincipalRoles(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoleCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrincipalRoles", reflect.TypeOf((*MockRoleCache)(nil).GetPrincipalRoles), arg0) } -// MockClientCache is a mock of ClientCache interface. +// MockClientCache is a mock of ClientCache interface type MockClientCache struct { ctrl *gomock.Controller recorder *MockClientCacheMockRecorder } -// MockClientCacheMockRecorder is the mock recorder for MockClientCache. +// MockClientCacheMockRecorder is the mock recorder for MockClientCache type MockClientCacheMockRecorder struct { mock *MockClientCache } -// NewMockClientCache creates a new mock instance. +// NewMockClientCache creates a new mock instance func NewMockClientCache(ctrl *gomock.Controller) *MockClientCache { mock := &MockClientCache{ctrl: ctrl} mock.recorder = &MockClientCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockClientCache) EXPECT() *MockClientCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockClientCache) Clear() error { +// Initialize mocks base method +func (m *MockClientCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockClientCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockClientCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockClientCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockClientCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockClientCache) Close() error { +// Update mocks base method +func (m *MockClientCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockClientCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockClientCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClientCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClientCache)(nil).Update)) } -// GetClient mocks base method. -func (m *MockClientCache) GetClient(id string) *model.Client { +// Clear mocks base method +func (m *MockClientCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetClient", id) - ret0, _ := ret[0].(*model.Client) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetClient indicates an expected call of GetClient. -func (mr *MockClientCacheMockRecorder) GetClient(id interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockClientCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientCache)(nil).GetClient), id) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockClientCache)(nil).Clear)) } -// GetClientsByFilter mocks base method. -func (m *MockClientCache) GetClientsByFilter(filters map[string]string, offset, limit uint32) (uint32, []*model.Client, error) { +// Name mocks base method +func (m *MockClientCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetClientsByFilter", filters, offset, limit) - ret0, _ := ret[0].(uint32) - ret1, _ := ret[1].([]*model.Client) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 } -// GetClientsByFilter indicates an expected call of GetClientsByFilter. -func (mr *MockClientCacheMockRecorder) GetClientsByFilter(filters, offset, limit interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockClientCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientsByFilter", reflect.TypeOf((*MockClientCache)(nil).GetClientsByFilter), filters, offset, limit) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockClientCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockClientCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockClientCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockClientCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockClientCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockClientCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClientCache)(nil).Close)) } -// IteratorClients mocks base method. -func (m *MockClientCache) IteratorClients(iterProc api.ClientIterProc) { +// GetClient mocks base method +func (m *MockClientCache) GetClient(id string) *model.Client { m.ctrl.T.Helper() - m.ctrl.Call(m, "IteratorClients", iterProc) + ret := m.ctrl.Call(m, "GetClient", id) + ret0, _ := ret[0].(*model.Client) + return ret0 } -// IteratorClients indicates an expected call of IteratorClients. -func (mr *MockClientCacheMockRecorder) IteratorClients(iterProc interface{}) *gomock.Call { +// GetClient indicates an expected call of GetClient +func (mr *MockClientCacheMockRecorder) GetClient(id interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorClients", reflect.TypeOf((*MockClientCache)(nil).IteratorClients), iterProc) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientCache)(nil).GetClient), id) } -// Name mocks base method. -func (m *MockClientCache) Name() string { +// IteratorClients mocks base method +func (m *MockClientCache) IteratorClients(iterProc api.ClientIterProc) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 + m.ctrl.Call(m, "IteratorClients", iterProc) } -// Name indicates an expected call of Name. -func (mr *MockClientCacheMockRecorder) Name() *gomock.Call { +// IteratorClients indicates an expected call of IteratorClients +func (mr *MockClientCacheMockRecorder) IteratorClients(iterProc interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockClientCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorClients", reflect.TypeOf((*MockClientCache)(nil).IteratorClients), iterProc) } -// Update mocks base method. -func (m *MockClientCache) Update() error { +// GetClientsByFilter mocks base method +func (m *MockClientCache) GetClientsByFilter(filters map[string]string, offset, limit uint32) (uint32, []*model.Client, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) - return ret0 + ret := m.ctrl.Call(m, "GetClientsByFilter", filters, offset, limit) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].([]*model.Client) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 } -// Update indicates an expected call of Update. -func (mr *MockClientCacheMockRecorder) Update() *gomock.Call { +// GetClientsByFilter indicates an expected call of GetClientsByFilter +func (mr *MockClientCacheMockRecorder) GetClientsByFilter(filters, offset, limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClientCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientsByFilter", reflect.TypeOf((*MockClientCache)(nil).GetClientsByFilter), filters, offset, limit) } -// MockGrayCache is a mock of GrayCache interface. +// MockGrayCache is a mock of GrayCache interface type MockGrayCache struct { ctrl *gomock.Controller recorder *MockGrayCacheMockRecorder } -// MockGrayCacheMockRecorder is the mock recorder for MockGrayCache. +// MockGrayCacheMockRecorder is the mock recorder for MockGrayCache type MockGrayCacheMockRecorder struct { mock *MockGrayCache } -// NewMockGrayCache creates a new mock instance. +// NewMockGrayCache creates a new mock instance func NewMockGrayCache(ctrl *gomock.Controller) *MockGrayCache { mock := &MockGrayCache{ctrl: ctrl} mock.recorder = &MockGrayCacheMockRecorder{mock} return mock } -// EXPECT returns an object that allows the caller to indicate expected use. +// EXPECT returns an object that allows the caller to indicate expected use func (m *MockGrayCache) EXPECT() *MockGrayCacheMockRecorder { return m.recorder } -// Clear mocks base method. -func (m *MockGrayCache) Clear() error { +// Initialize mocks base method +func (m *MockGrayCache) Initialize(c map[string]interface{}) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Clear") + ret := m.ctrl.Call(m, "Initialize", c) ret0, _ := ret[0].(error) return ret0 } -// Clear indicates an expected call of Clear. -func (mr *MockGrayCacheMockRecorder) Clear() *gomock.Call { +// Initialize indicates an expected call of Initialize +func (mr *MockGrayCacheMockRecorder) Initialize(c interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockGrayCache)(nil).Clear)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockGrayCache)(nil).Initialize), c) } -// Close mocks base method. -func (m *MockGrayCache) Close() error { +// Update mocks base method +func (m *MockGrayCache) Update() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Update") ret0, _ := ret[0].(error) return ret0 } -// Close indicates an expected call of Close. -func (mr *MockGrayCacheMockRecorder) Close() *gomock.Call { +// Update indicates an expected call of Update +func (mr *MockGrayCacheMockRecorder) Update() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGrayCache)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGrayCache)(nil).Update)) } -// GetGrayRule mocks base method. -func (m *MockGrayCache) GetGrayRule(name string) []*model0.ClientLabel { +// Clear mocks base method +func (m *MockGrayCache) Clear() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGrayRule", name) - ret0, _ := ret[0].([]*model0.ClientLabel) + ret := m.ctrl.Call(m, "Clear") + ret0, _ := ret[0].(error) return ret0 } -// GetGrayRule indicates an expected call of GetGrayRule. -func (mr *MockGrayCacheMockRecorder) GetGrayRule(name interface{}) *gomock.Call { +// Clear indicates an expected call of Clear +func (mr *MockGrayCacheMockRecorder) Clear() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrayRule", reflect.TypeOf((*MockGrayCache)(nil).GetGrayRule), name) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockGrayCache)(nil).Clear)) } -// HitGrayRule mocks base method. -func (m *MockGrayCache) HitGrayRule(name string, labels map[string]string) bool { +// Name mocks base method +func (m *MockGrayCache) Name() string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HitGrayRule", name, labels) - ret0, _ := ret[0].(bool) + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) return ret0 } -// HitGrayRule indicates an expected call of HitGrayRule. -func (mr *MockGrayCacheMockRecorder) HitGrayRule(name, labels interface{}) *gomock.Call { +// Name indicates an expected call of Name +func (mr *MockGrayCacheMockRecorder) Name() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitGrayRule", reflect.TypeOf((*MockGrayCache)(nil).HitGrayRule), name, labels) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockGrayCache)(nil).Name)) } -// Initialize mocks base method. -func (m *MockGrayCache) Initialize(c map[string]interface{}) error { +// Close mocks base method +func (m *MockGrayCache) Close() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Initialize", c) + ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 } -// Initialize indicates an expected call of Initialize. -func (mr *MockGrayCacheMockRecorder) Initialize(c interface{}) *gomock.Call { +// Close indicates an expected call of Close +func (mr *MockGrayCacheMockRecorder) Close() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockGrayCache)(nil).Initialize), c) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGrayCache)(nil).Close)) } -// Name mocks base method. -func (m *MockGrayCache) Name() string { +// GetGrayRule mocks base method +func (m *MockGrayCache) GetGrayRule(name string) []*model0.ClientLabel { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) + ret := m.ctrl.Call(m, "GetGrayRule", name) + ret0, _ := ret[0].([]*model0.ClientLabel) return ret0 } -// Name indicates an expected call of Name. -func (mr *MockGrayCacheMockRecorder) Name() *gomock.Call { +// GetGrayRule indicates an expected call of GetGrayRule +func (mr *MockGrayCacheMockRecorder) GetGrayRule(name interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockGrayCache)(nil).Name)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrayRule", reflect.TypeOf((*MockGrayCache)(nil).GetGrayRule), name) } -// Update mocks base method. -func (m *MockGrayCache) Update() error { +// HitGrayRule mocks base method +func (m *MockGrayCache) HitGrayRule(name string, labels map[string]string) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update") - ret0, _ := ret[0].(error) + ret := m.ctrl.Call(m, "HitGrayRule", name, labels) + ret0, _ := ret[0].(bool) return ret0 } -// Update indicates an expected call of Update. -func (mr *MockGrayCacheMockRecorder) Update() *gomock.Call { +// HitGrayRule indicates an expected call of HitGrayRule +func (mr *MockGrayCacheMockRecorder) HitGrayRule(name, labels interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGrayCache)(nil).Update)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HitGrayRule", reflect.TypeOf((*MockGrayCache)(nil).HitGrayRule), name, labels) } diff --git a/cache/service/service.go b/cache/service/service.go index 6b3ae7e56..d77da181b 100644 --- a/cache/service/service.go +++ b/cache/service/service.go @@ -634,8 +634,43 @@ func (sc *serviceCache) updateCl5SidAndNames(service *model.Service) { sc.cl5Names.Store(cl5Name, service) } -// GetVisibleServicesInOtherNamespace 查询是否存在别的命名空间下存在名称相同且可见的服务 -func (sc *serviceCache) GetVisibleServicesInOtherNamespace(svcName, namespace string) []*model.Service { +// GetVisibleServices get all services in other namespace and it's visible +func (sc *serviceCache) GetVisibleServices(ctx context.Context, namespace string) []*model.Service { + ret := make(map[string]*model.Service) + // 根据服务级别的可见性进行查询 + sc.exportServices.ReadRange(func(exportToNs string, services *utils.SyncMap[string, *model.Service]) { + if exportToNs != namespace && exportToNs != types.AllMatched { + return + } + services.ReadRange(func(_ string, svc *model.Service) { + if _, ok := ret[svc.ID]; !ok { + ret[svc.ID] = svc + } + }) + }) + // 根据命名空间级别的可见性进行查询, 先看精确的 + sc.exportNamespace.ReadRange(func(exportNs string, viewerNs *utils.SyncSet[string]) { + exactMatch := viewerNs.Contains(namespace) + allMatch := viewerNs.Contains(types.AllMatched) + if !exactMatch && !allMatch { + return + } + _, services := sc.ListServices(ctx, exportNs) + for _, svc := range services { + if _, ok := ret[svc.ID]; !ok { + ret[svc.ID] = svc + } + } + }) + visibleServices := make([]*model.Service, 0, len(ret)) + for _, svc := range ret { + visibleServices = append(visibleServices, svc) + } + return visibleServices +} + +// GetVisibleSameNameServices 查询是否存在别的命名空间下存在名称相同且可见的服务 +func (sc *serviceCache) GetVisibleSameNameServices(svcName, namespace string) []*model.Service { ret := make(map[string]*model.Service) // 根据服务级别的可见性进行查询, 先查询精确匹配 sc.exportServices.ReadRange(func(exportToNs string, services *utils.SyncMap[string, *model.Service]) { @@ -663,6 +698,7 @@ func (sc *serviceCache) GetVisibleServicesInOtherNamespace(svcName, namespace st ret[svc.ID] = svc }) + existSvcs := make(map[string]struct{}) visibleServices := make([]*model.Service, 0, len(ret)) for _, svc := range ret { if svc.IsAlias() { @@ -676,6 +712,10 @@ func (sc *serviceCache) GetVisibleServicesInOtherNamespace(svcName, namespace st continue } } + if _, ok := existSvcs[svc.ID]; ok { + continue + } + existSvcs[svc.ID] = struct{}{} visibleServices = append(visibleServices, svc) } @@ -686,6 +726,14 @@ func (sc *serviceCache) postProcessServiceExports(services map[string]*model.Ser for i := range services { svc := services[i] + if !svc.Valid { + // 服务被删除了，把所有的可见性都取消 + // delete export services cache + sc.exportServices.ReadRange(func(key string, val *utils.SyncMap[string, *model.Service]) { + val.Delete(svc.ID) + }) + continue + } for exportNs := range svc.OldExportTo { if _, ok := svc.ExportTo[exportNs]; ok { continue @@ -725,6 +773,7 @@ func (sc *serviceCache) handleNamespaceChange(ctx context.Context, args interfac } case eventhub.EventDeleted: sc.exportNamespace.Delete(event.Item.Name) + sc.exportServices.Delete(event.Item.Name) } return nil } @@ -737,7 +786,7 @@ func (sc *serviceCache) notifyRevisionWorker(serviceID string, valid bool) { revisionWorker.Notify(serviceID, valid) } -// GetRevisionWorker +// GetRevisionWorker . func (sc *serviceCache) GetRevisionWorker() types.ServiceRevisionWorker { return sc.revisionWorker } diff --git a/cache/service/service_test.go b/cache/service/service_test.go index b9015e3ec..52565e172 100644 --- a/cache/service/service_test.go +++ b/cache/service/service_test.go @@ -467,16 +467,16 @@ func TestServiceCache_NamespaceCount(t *testing.T) { sc.setServices(services) time.Sleep(time.Duration(5 * time.Second)) - acutalNsCount := make(map[string]int) + actualNsCount := make(map[string]int) for i := range nsList { ns := nsList[i] - acutalNsCount[ns] = int(sc.GetNamespaceCntInfo(ns).InstanceCnt.TotalInstanceCount) + actualNsCount[ns] = int(sc.GetNamespaceCntInfo(ns).InstanceCnt.TotalInstanceCount) } fmt.Printf("expect ns count : %#v\n", expectNsCount) - fmt.Printf("acutal ns count : %#v\n", acutalNsCount) + fmt.Printf("acutal ns count : %#v\n", actualNsCount) - if !reflect.DeepEqual(expectNsCount, acutalNsCount) { + if !reflect.DeepEqual(expectNsCount, actualNsCount) { t.Fatal("namespace count is no currect") } }) @@ -650,9 +650,9 @@ func Test_serviceCache_GetVisibleServicesInOtherNamespace(t *testing.T) { }) _, _, _ = svcCache.setServices(serviceList) - visibles := svcCache.GetVisibleServicesInOtherNamespace("service-1", "ns-2") - assert.Equal(t, 1, len(visibles)) - assert.Equal(t, "ns-1", visibles[0].Namespace) + visibleServices := svcCache.GetVisibleSameNameServices("service-1", "ns-2") + assert.Equal(t, 1, len(visibleServices)) + assert.Equal(t, "ns-1", visibleServices[0].Namespace) }) t.Run("服务可见性查询判断", func(t *testing.T) { @@ -707,15 +707,15 @@ func Test_serviceCache_GetVisibleServicesInOtherNamespace(t *testing.T) { }, }) - visibles := svcCache.GetVisibleServicesInOtherNamespace("service-1", "ns-2") + visibles := svcCache.GetVisibleSameNameServices("service-1", "ns-2") assert.Equal(t, 1, len(visibles)) assert.Equal(t, "ns-1", visibles[0].Namespace) - visibles = svcCache.GetVisibleServicesInOtherNamespace("service-1", "ns-3") + visibles = svcCache.GetVisibleSameNameServices("service-1", "ns-3") assert.Equal(t, 1, len(visibles)) assert.Equal(t, "ns-1", visibles[0].Namespace) - visibles = svcCache.GetVisibleServicesInOtherNamespace("service-1", "ns-4") + visibles = svcCache.GetVisibleSameNameServices("service-1", "ns-4") assert.Equal(t, 0, len(visibles)) }) diff --git a/common/api/v1/naming_response.go b/common/api/v1/naming_response.go index c2f516b68..974f41328 100644 --- a/common/api/v1/naming_response.go +++ b/common/api/v1/naming_response.go @@ -188,6 +188,15 @@ func NewRoutingResponse(code apimodel.Code, routing *apitraffic.Routing) *apiser } } +// NewServiceContractResponse create the response with data with any type +func NewServiceContractResponse(code apimodel.Code, contract *apiservice.ServiceContract) *apiservice.Response { + return &apiservice.Response{ + Code: &wrappers.UInt32Value{Value: uint32(code)}, + Info: &wrappers.StringValue{Value: code2info[uint32(code)]}, + ServiceContract: contract, + } +} + // NewAnyDataResponse create the response with data with any type func NewAnyDataResponse(code apimodel.Code, msg proto.Message) *apiservice.Response { ret, err := anypb.New(proto.MessageV2(msg)) diff --git a/common/model/contract.go b/common/model/contract.go index e2feab3f5..421d764c4 100644 --- a/common/model/contract.go +++ b/common/model/contract.go @@ -42,6 +42,12 @@ type ServiceContract struct { Revision string // 额外描述 Content string + // 内容摘要 + ContentDigest string + // 服务接口标签信息 + Metadata map[string]string + // 服务接口标签序列化的字符串 + MetadataStr string // 创建时间 CreateTime time.Time // 更新时间 @@ -59,6 +65,14 @@ type EnrichServiceContract struct { ManualInterfaces map[string]*InterfaceDescriptor } +// IsManual 是否手动添加的契约 +func (e *EnrichServiceContract) IsManual() bool { + if len(e.ClientInterfaces) == 0 && len(e.ManualInterfaces) == 0 { + return false + } + return len(e.ManualInterfaces) > 0 +} + func (e *EnrichServiceContract) Format() { if e.isFormated { return @@ -89,9 +103,6 @@ func (e *EnrichServiceContract) Format() { } e.Interfaces = append(e.Interfaces, e.ClientInterfaces[k]) } - // 格式化完毕之后，清空暂存的 ClientInterface 以及 ManualInterface 数据 - e.ClientInterfaces = nil - e.ManualInterfaces = nil } func (e *EnrichServiceContract) ToSpec() *apiservice.ServiceContract { @@ -135,6 +146,12 @@ func (s *ServiceContract) GetCacheKey() string { return fmt.Sprintf("%s/%s/%s/%s/%s", s.Namespace, s.Service, s.Type, s.Protocol, s.Version) } +// GetServiceContractCacheKey 生成契约唯一KEY +func GetServiceContractCacheKey(contract *apiservice.ServiceContract) string { + return fmt.Sprintf("%s/%s/%s/%s/%s", contract.Namespace, contract.Service, contract.Type, + contract.Protocol, contract.Version) +} + type InterfaceDescriptor struct { // ID ID string @@ -156,6 +173,8 @@ type InterfaceDescriptor struct { Path string // 接口描述信息 Content string + // 接口内容摘要 + ContentDigest string // 接口信息摘要 Revision string // 创建来源 @@ -167,3 +186,23 @@ type InterfaceDescriptor struct { // Valid Valid bool } + +func (i *InterfaceDescriptor) ToSpec() *apiservice.InterfaceDescriptor { + return &apiservice.InterfaceDescriptor{ + Id: i.ID, + Method: i.Method, + Path: i.Path, + Content: i.Content, + ContentDigest: i.ContentDigest, + Source: i.Source, + Revision: i.Revision, + Ctime: commontime.Time2String(i.CreateTime), + Mtime: commontime.Time2String(i.CreateTime), + Name: i.Type, + Namespace: i.Namespace, + Service: i.Service, + Protocol: i.Protocol, + Version: i.Version, + Type: i.Type, + } +} diff --git a/common/model/naming.go b/common/model/naming.go index 9394ca3f9..58b602c3c 100644 --- a/common/model/naming.go +++ b/common/model/naming.go @@ -549,6 +549,8 @@ type Instance struct { Valid bool // ModifyTime Update time of instance ModifyTime time.Time + // CreateTime Create time of instance + CreateTime time.Time } // ID get id diff --git a/common/utils/common.go b/common/utils/common.go index f08c1f852..6b6f14acf 100644 --- a/common/utils/common.go +++ b/common/utils/common.go @@ -21,9 +21,11 @@ import ( "context" "crypto/sha1" "encoding/hex" + "encoding/json" "errors" "fmt" "io" + "reflect" "regexp" "strconv" "strings" @@ -579,6 +581,19 @@ func CheckContractTetrad(req *apiservice.ServiceContract) (string, *apiservice.R return hex.EncodeToString(h.Sum(nil)), nil } +// BuildSha1Digest 构建SHA1摘要 +func BuildSha1Digest(value string) (string, error) { + if len(value) == 0 { + return "", nil + } + h := sha1.New() + if _, err := io.WriteString(h, value); err != nil { + return "", err + } + out := hex.EncodeToString(h.Sum(nil)) + return out, nil +} + func CheckContractInterfaceTetrad(contractId string, source apiservice.InterfaceDescriptor_Source, req *apiservice.InterfaceDescriptor) (string, *apiservice.Response) { if contractId == "" { @@ -611,3 +626,39 @@ func CalculateContractID(namespace, service, name, protocol, version string) (st out := hex.EncodeToString(h.Sum(nil)) return out, nil } + +// ConvertMetadataToStringValue 将Metadata转换为可序列化字符串 +func ConvertMetadataToStringValue(metadata map[string]string) (string, error) { + if metadata == nil { + return "", nil + } + v, err := json.Marshal(metadata) + if err != nil { + return "", err + } + return string(v), nil +} + +// ConvertStringValueToMetadata 将字符串反序列为metadata +func ConvertStringValueToMetadata(str string) (map[string]string, error) { + if str == "" { + return nil, nil + } + v := make(map[string]string) + err := json.Unmarshal([]byte(str), &v) + if err != nil { + return nil, err + } + return v, nil +} + +// NeedUpdateMetadata 判断是否出现了metadata的变更 +func NeedUpdateMetadata(metadata map[string]string, inMetadata map[string]string) bool { + if inMetadata == nil { + return false + } + if len(metadata) != len(inMetadata) { + return true + } + return !reflect.DeepEqual(metadata, inMetadata) +} diff --git a/go.mod b/go.mod index f2590eca3..1971b9c4f 100644 --- a/go.mod +++ b/go.mod @@ -78,7 +78,7 @@ require ( require ( github.com/DATA-DOG/go-sqlmock v1.5.0 - github.com/polarismesh/specification v1.5.3-alpha.2 + github.com/polarismesh/specification v1.5.5-alpha.1 ) require ( diff --git a/go.sum b/go.sum index ef02521f5..0794a8d1b 100644 --- a/go.sum +++ b/go.sum @@ -300,8 +300,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/polarismesh/go-restful-openapi/v2 v2.0.0-20220928152401-083908d10219 h1:XnFyNUWnciM6zgXaz6tm+Egs35rhoD0KGMmKh4gCdi0= github.com/polarismesh/go-restful-openapi/v2 v2.0.0-20220928152401-083908d10219/go.mod h1:4WhwBysTom9Eoy0hQ4W69I0FmO+T0EpjEW9/5sgHoUk= -github.com/polarismesh/specification v1.5.3-alpha.2 h1:QSgpGmx5VfPcDPAq7qnTOkMVFNpmBMgLSDhtyMlS6/g= -github.com/polarismesh/specification v1.5.3-alpha.2/go.mod h1:rDvMMtl5qebPmqiBLNa5Ps0XtwkP31ZLirbH4kXA0YU= +github.com/polarismesh/specification v1.5.5-alpha.1 h1:lGLaj+I6iD25F0FuQnR83sR+1SJ8KqykS0vCnGx2ZAQ= +github.com/polarismesh/specification v1.5.5-alpha.1/go.mod h1:rDvMMtl5qebPmqiBLNa5Ps0XtwkP31ZLirbH4kXA0YU= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk= github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA= diff --git a/plugin/healthchecker/leader/checker_leader.go b/plugin/healthchecker/leader/checker_leader.go index e65f6bc0c..57e8589cf 100644 --- a/plugin/healthchecker/leader/checker_leader.go +++ b/plugin/healthchecker/leader/checker_leader.go @@ -455,7 +455,7 @@ func (c *LeaderHealthChecker) skipCheck(key string, expireDurationSec int64) boo localCurTimeSec-leaderChangeTimeSec < expireDurationSec { log.Infof("[Health Check][Leader] health check peers on refresh, "+ "refreshPeerTimeSec is %d, localCurTimeSec is %d, expireDurationSec is %d, id %s", - suspendTimeSec, localCurTimeSec, expireDurationSec, key) + leaderChangeTimeSec, localCurTimeSec, expireDurationSec, key) return true } return false @@ -492,11 +492,16 @@ func (c *LeaderHealthChecker) DebugHandlers() []model.DebugHandler { } } +// isSendFromPeer 从ctx中解析请求header信息，检查请求是否来自于远端 func isSendFromPeer(ctx context.Context) bool { - if md, ok := metadata.FromIncomingContext(ctx); ok { - if _, exist := md[sendResource]; exist { - return true - } + md, ok := ctx.Value(utils.ContextGrpcHeader).(metadata.MD) + if !ok { + return false } + // log.Info("[Health Check][leader] get ContextGrpcHeader from remote", zap.Any("md", md)) + if _, exist := md[sendResource]; exist { + return true + } + return false } diff --git a/plugin/healthchecker/leader/peer.go b/plugin/healthchecker/leader/peer.go index 03f5b4b22..22ccdb5ca 100644 --- a/plugin/healthchecker/leader/peer.go +++ b/plugin/healthchecker/leader/peer.go @@ -58,6 +58,10 @@ var ( CreateBeatClientFunc = createBeatClient ) +var ( + DefaultRequestTimeout = time.Second * 5 +) + func newLocalPeer() Peer { return &LocalPeer{} } @@ -189,10 +193,12 @@ func (p *RemotePeer) Ping() error { if err != nil { return err } - _, err = client.BatchGetHeartbeat(context.Background(), &apiservice.GetHeartbeatsRequest{}, - grpc.Header(&metadata.MD{ - sendResource: []string{utils.LocalHost}, - })) + + ctx, cancel := context.WithTimeout(context.Background(), DefaultRequestTimeout) + defer cancel() + + ctx = metadata.AppendToOutgoingContext(ctx, sendResource, utils.LocalHost) + _, err = client.BatchGetHeartbeat(ctx, &apiservice.GetHeartbeatsRequest{}) return err } @@ -213,9 +219,12 @@ func (p *RemotePeer) GetFunc(req *apiservice.GetHeartbeatsRequest) (*apiservice. if err != nil { return nil, err } - resp, err := client.BatchGetHeartbeat(context.Background(), req, grpc.Header(&metadata.MD{ - sendResource: []string{utils.LocalHost}, - })) + + ctx, cancel := context.WithTimeout(context.Background(), DefaultRequestTimeout) + defer cancel() + + ctx = metadata.AppendToOutgoingContext(ctx, sendResource, utils.LocalHost) + resp, err := client.BatchGetHeartbeat(ctx, req) if err != nil { code = "-1" plog.Error("[HealthCheck][Leader] send get record request", zap.String("host", p.Host()), @@ -268,9 +277,11 @@ func (p *RemotePeer) DelFunc(req *apiservice.DelHeartbeatsRequest) error { if err != nil { return err } - if _, err := client.BatchDelHeartbeat(context.Background(), req, grpc.Header(&metadata.MD{ - sendResource: []string{utils.LocalHost}, - })); err != nil { + ctx, cancel := context.WithTimeout(context.Background(), DefaultRequestTimeout) + defer cancel() + + ctx = metadata.AppendToOutgoingContext(ctx, sendResource, utils.LocalHost) + if _, err := client.BatchDelHeartbeat(ctx, req); err != nil { code = "-1" plog.Error("send del record request", zap.String("host", p.Host()), zap.Uint32("port", p.port), zap.Error(err)) @@ -460,9 +471,8 @@ func doConnect(p *RemotePeer) error { func newBeatSender(index int, conn *grpc.ClientConn, p *RemotePeer) (*beatSender, error) { client := apiservice.NewPolarisHeartbeatGRPCClient(conn) - puter, err := client.BatchHeartbeat(context.Background(), grpc.Header(&metadata.MD{ - sendResource: []string{utils.LocalHost}, - })) + ctx := metadata.AppendToOutgoingContext(context.Background(), sendResource, utils.LocalHost) + puter, err := client.BatchHeartbeat(ctx) if err != nil { return nil, err } diff --git a/service/client_v1.go b/service/client_v1.go index 03924acc2..931ab4d8c 100644 --- a/service/client_v1.go +++ b/service/client_v1.go @@ -168,32 +168,54 @@ func (s *Server) GetPrometheusTargets(ctx context.Context, // GetServiceWithCache 查询服务列表 func (s *Server) GetServiceWithCache(ctx context.Context, req *apiservice.Service) *apiservice.DiscoverResponse { + if s.caches == nil { + return api.NewDiscoverServiceResponse(apimodel.Code_ClientAPINotOpen, req) + } + if req == nil { + return api.NewDiscoverServiceResponse(apimodel.Code_EmptyRequest, req) + } + resp := api.NewDiscoverServiceResponse(apimodel.Code_ExecuteSuccess, req) var ( revision string - svcs []*model.Service + services []*model.Service + err error ) if req.GetNamespace().GetValue() != "" { - revision, svcs = s.Cache().Service().ListServices(ctx, req.GetNamespace().GetValue()) + revision, services = s.Cache().Service().ListServices(ctx, req.GetNamespace().GetValue()) + // 需要加上服务可见性处理 + visibleServices := s.caches.Service().GetVisibleServices(ctx, req.GetNamespace().GetValue()) + revisions := make([]string, 0, len(visibleServices)+1) + revisions = append(revisions, revision) + for _, visibleService := range visibleServices { + revisions = append(revisions, visibleService.Revision) + } + if revision, err = cachetypes.CompositeComputeRevision(revisions); err != nil { + log.Error("[Server][Discover] list services compute multi revision", + zap.String("namespace", req.GetNamespace().GetValue()), zap.Error(err)) + return api.NewDiscoverInstanceResponse(apimodel.Code_ExecuteException, req) + } + services = append(services, visibleServices...) } else { - revision, svcs = s.Cache().Service().ListAllServices(ctx) + revision, services = s.Cache().Service().ListAllServices(ctx) } if revision == "" { return resp } - log.Debug("[Service][Discover] list servies", zap.Int("size", len(svcs)), zap.String("revision", revision)) + log.Debug("[Service][Discover] list services", zap.Int("size", len(services)), + zap.String("revision", revision)) if revision == req.GetRevision().GetValue() { return api.NewDiscoverServiceResponse(apimodel.Code_DataNoChange, req) } - ret := make([]*apiservice.Service, 0, len(svcs)) - for i := range svcs { + ret := make([]*apiservice.Service, 0, len(services)) + for _, svc := range services { ret = append(ret, &apiservice.Service{ - Namespace: utils.NewStringValue(svcs[i].Namespace), - Name: utils.NewStringValue(svcs[i].Name), - Metadata: svcs[i].Meta, + Namespace: utils.NewStringValue(svc.Namespace), + Name: utils.NewStringValue(svc.Name), + Metadata: svc.Meta, }) } @@ -215,6 +237,15 @@ func (s *Server) ServiceInstancesCache(ctx context.Context, filter *apiservice.D serviceName := req.GetName().GetValue() namespaceName := req.GetNamespace().GetValue() + // 消费服务为了兼容，可以不带namespace，server端使用默认的namespace + if namespaceName == "" { + namespaceName = DefaultNamespace + req.Namespace = utils.NewStringValue(namespaceName) + } + if !s.commonCheckDiscoverRequest(req, resp) { + return resp + } + // 数据源都来自Cache，这里拿到的service，已经是源服务 aliasFor, visibleServices := s.findVisibleServices(serviceName, namespaceName, req) if len(visibleServices) == 0 { @@ -225,6 +256,20 @@ func (s *Server) ServiceInstancesCache(ctx context.Context, filter *apiservice.D revisions := make([]string, 0, len(visibleServices)+1) finalInstances := make(map[string]*apiservice.Instance, 128) + for _, svc := range visibleServices { + revision := s.caches.Service().GetRevisionWorker().GetServiceInstanceRevision(svc.ID) + revisions = append(revisions, revision) + } + aggregateRevision, err := cachetypes.CompositeComputeRevision(revisions) + if err != nil { + log.Errorf("[Server][Service][Instance] compute multi revision service(%s:%s) err: %s", + serviceName, namespaceName, err.Error()) + return api.NewDiscoverInstanceResponse(apimodel.Code_ExecuteException, req) + } + if aggregateRevision == req.GetRevision().GetValue() { + return api.NewDiscoverInstanceResponse(apimodel.Code_DataNoChange, req) + } + for _, svc := range visibleServices { specSvc := &apiservice.Service{ Id: utils.NewStringValue(svc.ID), @@ -232,16 +277,6 @@ func (s *Server) ServiceInstancesCache(ctx context.Context, filter *apiservice.D Namespace: utils.NewStringValue(svc.Namespace), } ret := s.caches.Instance().DiscoverServiceInstances(specSvc.GetId().GetValue(), filter.GetOnlyHealthyInstance()) - // 如果是空实例，则直接跳过，不处理实例列表以及 revision 信息 - if len(ret) == 0 { - continue - } - revision := s.caches.Service().GetRevisionWorker().GetServiceInstanceRevision(svc.ID) - if revision == "" { - revision = utils.NewUUID() - } - revisions = append(revisions, revision) - for i := range ret { copyIns := s.getInstance(specSvc, ret[i].Proto) // 注意：这里的value是cache的，不修改cache的数据，通过getInstance，浅拷贝一份数据 @@ -249,16 +284,11 @@ func (s *Server) ServiceInstancesCache(ctx context.Context, filter *apiservice.D } } - aggregateRevision, err := cachetypes.CompositeComputeRevision(revisions) - if err != nil { - log.Errorf("[Server][Service][Instance] compute multi revision service(%s) err: %s", - aliasFor.ID, err.Error()) - return api.NewDiscoverInstanceResponse(apimodel.Code_ExecuteException, req) - } - if aggregateRevision == req.GetRevision().GetValue() { - return api.NewDiscoverInstanceResponse(apimodel.Code_DataNoChange, req) + if aliasFor == nil { + // 这里只会出现，查询的目标服务和命名空间不存在，但是可见性的服务存在 + // 所以这里需要用入口的服务名和命名空间填充服务数据结构，以便返回最终的应答服务名和命名空间 + aliasFor = &model.Service{Name: serviceName, Namespace: namespaceName} } - // 填充service数据 resp.Service = service2Api(aliasFor) // 这里需要把服务信息改为用户请求的服务名以及命名空间 @@ -281,9 +311,15 @@ func (s *Server) findVisibleServices(serviceName, namespaceName string, req *api // 数据源都来自Cache，这里拿到的service，已经是源服务 aliasFor := s.getServiceCache(serviceName, namespaceName) if aliasFor != nil { + // 获取到实际的服务，则将查询的服务名替换成实际的服务名和命名空间 + serviceName = aliasFor.Name + namespaceName = aliasFor.Namespace + // 先把自己放进去 visibleServices = append(visibleServices, aliasFor) } - ret := s.caches.Service().GetVisibleServicesInOtherNamespace(serviceName, namespaceName) + // 根据服务名和命名空间获取可见的服务列表 + // 这里的serviceName和namespaceName，可能是传入的服务名和命名空间，也可能是通过别名查询后获取的匹配的服务名和命名空间 + ret := s.caches.Service().GetVisibleSameNameServices(serviceName, namespaceName) if len(ret) > 0 { visibleServices = append(visibleServices, ret...) } @@ -556,3 +592,33 @@ func (s *Server) getServiceCache(name string, namespace string) *model.Service { } return service } + +func (s *Server) commonCheckDiscoverRequest(req *apiservice.Service, resp *apiservice.DiscoverResponse) bool { + if s.caches == nil { + resp.Code = utils.NewUInt32Value(uint32(apimodel.Code_ClientAPINotOpen)) + resp.Info = utils.NewStringValue(api.Code2Info(resp.GetCode().GetValue())) + resp.Service = req + return false + } + if req == nil { + resp.Code = utils.NewUInt32Value(uint32(apimodel.Code_EmptyRequest)) + resp.Info = utils.NewStringValue(api.Code2Info(resp.GetCode().GetValue())) + resp.Service = req + return false + } + + if req.GetName().GetValue() == "" { + resp.Code = utils.NewUInt32Value(uint32(apimodel.Code_InvalidServiceName)) + resp.Info = utils.NewStringValue(api.Code2Info(resp.GetCode().GetValue())) + resp.Service = req + return false + } + if req.GetNamespace().GetValue() == "" { + resp.Code = utils.NewUInt32Value(uint32(apimodel.Code_InvalidNamespaceName)) + resp.Info = utils.NewStringValue(api.Code2Info(resp.GetCode().GetValue())) + resp.Service = req + return false + } + + return true +} diff --git a/service/default.go b/service/default.go index 1efa4bc14..90de012e9 100644 --- a/service/default.go +++ b/service/default.go @@ -145,7 +145,7 @@ func InitServer(ctx context.Context, namingOpt *Config, opts ...InitOption) (*Se return actualSvr, proxySvr, nil } -func (svr *Server) Initialize(context.Context, store.Store) error { +func (s *Server) Initialize(context.Context, store.Store) error { return nil } @@ -161,16 +161,16 @@ func (p *PluginInstanceEventHandler) OnEvent(ctx context.Context, any2 any) erro } // 插件初始化 -func (svr *Server) pluginInitialize() { +func (s *Server) pluginInitialize() { // 获取CMDB插件 - svr.cmdb = plugin.GetCMDB() - if svr.cmdb == nil { + s.cmdb = plugin.GetCMDB() + if s.cmdb == nil { log.Warnf("Not Found CMDB Plugin") } // 获取History插件，注意：插件的配置在bootstrap已经设置好 - svr.history = plugin.GetHistory() - if svr.history == nil { + s.history = plugin.GetHistory() + if s.history == nil { log.Warnf("Not Found History Log Plugin") } @@ -181,14 +181,14 @@ func (svr *Server) pluginInitialize() { } eventHandler := &PluginInstanceEventHandler{ - BaseInstanceEventHandler: NewBaseInstanceEventHandler(svr), + BaseInstanceEventHandler: NewBaseInstanceEventHandler(s), subscriber: subscriber, } subCtx, err := eventhub.Subscribe(eventhub.InstanceEventTopic, eventHandler) if err != nil { log.Warnf("register DiscoverEvent into eventhub:%s %v", subscriber.Name(), err) } - svr.subCtxs = append(svr.subCtxs, subCtx) + s.subCtxs = append(s.subCtxs, subCtx) } func GetChainOrder() []string { diff --git a/service/service_contract.go b/service/service_contract.go index 475c90964..c2ebcd526 100644 --- a/service/service_contract.go +++ b/service/service_contract.go @@ -19,6 +19,7 @@ package service import ( "context" + "strings" "time" "github.com/gogo/protobuf/jsonpb" @@ -29,7 +30,6 @@ import ( api "github.com/polarismesh/polaris/common/api/v1" "github.com/polarismesh/polaris/common/model" - "github.com/polarismesh/polaris/common/store" commonstore "github.com/polarismesh/polaris/common/store" commontime "github.com/polarismesh/polaris/common/time" "github.com/polarismesh/polaris/common/utils" @@ -37,18 +37,34 @@ import ( var ( contractSearchFilters = map[string]string{ - "id": "id", - "namespace": "namespace", - "service": "service", - "name": "type", - "type": "type", - "protocol": "protocol", - "version": "version", - "brief": "brief", - "offset": "offset", - "limit": "limit", - "interface_name": "interface_name", - "interface_path": "interface_path", + "id": "id", + "namespace": "namespace", + "service": "service", + "name": "type", + "type": "type", + "protocol": "protocol", + "version": "version", + "brief": "brief", + "offset": "offset", + "limit": "limit", + "order_field": "order_field", + "order_type": "order_type", + } + + interfaceSearchFilters = map[string]string{ + "id": "id", + "namespace": "namespace", + "service": "service", + "name": "type", + "type": "type", + "protocol": "protocol", + "version": "version", + "path": "path", + "method": "method", + "offset": "offset", + "limit": "limit", + "order_field": "order_field", + "order_type": "order_type", } ) @@ -64,6 +80,9 @@ func (s *Server) CreateServiceContracts(ctx context.Context, } func (s *Server) CreateServiceContract(ctx context.Context, contract *apiservice.ServiceContract) *apiservice.Response { + if errRsp := checkBaseServiceContract(contract); errRsp != nil { + return errRsp + } contractId := contract.GetId() if contractId == "" { tmpId, errRsp := utils.CheckContractTetrad(contract) @@ -77,22 +96,40 @@ func (s *Server) CreateServiceContract(ctx context.Context, contract *apiservice if err != nil { log.Error("[Service][Contract] get service_contract from store when create", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), contract) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } if existContract != nil { - if existContract.Content == contract.Content { - return api.NewAnyDataResponse(apimodel.Code_NoNeedUpdate, nil) + var needUpdate = false + if existContract.Content != contract.Content { + existContract.Content = contract.Content + if existContract.ContentDigest, err = utils.BuildSha1Digest(existContract.Content); err != nil { + log.Error("[Service][Contract] do build content digest for update contract", utils.RequestID(ctx), + zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + needUpdate = true + } + if utils.NeedUpdateMetadata(existContract.Metadata, contract.Metadata) { + existContract.Metadata = contract.Metadata + if existContract.MetadataStr, err = utils.ConvertMetadataToStringValue(existContract.Metadata); err != nil { + log.Error("[Service][Contract] do serialize metadata for update contract", utils.RequestID(ctx), + zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + needUpdate = true + } + if !needUpdate { + return api.NewServiceContractResponse(apimodel.Code_NoNeedUpdate, nil) } - existContract.Content = contract.Content existContract.Revision = utils.NewUUID() if err := s.storage.UpdateServiceContract(existContract.ServiceContract); err != nil { log.Error("[Service][Contract] do update to store", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), contract) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, &model.EnrichServiceContract{ ServiceContract: existContract.ServiceContract, }, model.OUpdate)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, &apiservice.ServiceContract{Id: contractId}) } saveData := &model.ServiceContract{ @@ -104,23 +141,38 @@ func (s *Server) CreateServiceContract(ctx context.Context, contract *apiservice Version: contract.GetVersion(), Revision: utils.NewUUID(), Content: contract.GetContent(), + Metadata: contract.Metadata, + } + if saveData.ContentDigest, err = utils.BuildSha1Digest(saveData.Content); err != nil { + log.Error("[Service][Contract] do build content digest for create contract", utils.RequestID(ctx), zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + if saveData.MetadataStr, err = utils.ConvertMetadataToStringValue(saveData.Metadata); err != nil { + log.Error("[Service][Contract] do serialize metadata for create contract", utils.RequestID(ctx), zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } if err := s.storage.CreateServiceContract(saveData); err != nil { log.Error("[Service][Contract] do save to store", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, &model.EnrichServiceContract{ ServiceContract: saveData, }, model.OCreate)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, &apiservice.ServiceContract{Id: contractId}) } func (s *Server) GetServiceContracts(ctx context.Context, query map[string]string) *apiservice.BatchQueryResponse { + out := api.NewBatchQueryResponse(apimodel.Code_ExecuteSuccess) out.Amount = utils.NewUInt32Value(0) out.Size = utils.NewUInt32Value(0) + var isBrief = false + if bValue, ok := query[briefSearch]; ok && strings.ToLower(bValue) == "true" { + isBrief = true + delete(query, briefSearch) + } searchFilters := map[string]string{} for k, v := range query { newK, ok := contractSearchFilters[k] @@ -138,6 +190,13 @@ func (s *Server) GetServiceContracts(ctx context.Context, query map[string]strin return out } + if _, ok := searchFilters["order_field"]; !ok { + searchFilters["order_field"] = "mtime" + } + if _, ok := searchFilters["order_type"]; !ok { + searchFilters["order_type"] = "desc" + } + totalCount, ret, err := s.storage.GetServiceContracts(ctx, searchFilters, offset, limit) if err != nil { out = api.NewBatchQueryResponseWithMsg(commonstore.StoreCode2APICode(err), err.Error()) @@ -146,16 +205,23 @@ func (s *Server) GetServiceContracts(ctx context.Context, query map[string]strin for _, item := range ret { methods := make([]*apiservice.InterfaceDescriptor, 0) for _, methodItem := range item.Interfaces { - methods = append(methods, &apiservice.InterfaceDescriptor{ - Id: methodItem.ID, - Method: methodItem.Method, - Path: methodItem.Path, - Content: methodItem.Content, - Revision: methodItem.Revision, - Source: methodItem.Source, - Ctime: commontime.Time2String(methodItem.CreateTime), - Mtime: commontime.Time2String(methodItem.ModifyTime), - }) + intf := &apiservice.InterfaceDescriptor{ + Id: methodItem.ID, + Method: methodItem.Method, + Name: methodItem.Type, + Type: methodItem.Type, + Path: methodItem.Path, + Content: methodItem.Content, + ContentDigest: methodItem.ContentDigest, + Revision: methodItem.Revision, + Source: methodItem.Source, + Ctime: commontime.Time2String(methodItem.CreateTime), + Mtime: commontime.Time2String(methodItem.ModifyTime), + } + if isBrief { + intf.Content = "" + } + methods = append(methods, intf) } status := "Offline" @@ -169,19 +235,24 @@ func (s *Server) GetServiceContracts(ctx context.Context, query map[string]strin } contract := &apiservice.ServiceContract{ - Id: item.ID, - Name: item.Type, - Type: item.Type, - Namespace: item.Namespace, - Service: item.Service, - Protocol: item.Protocol, - Version: item.Version, - Revision: item.Revision, - Content: item.Content, - Interfaces: methods, - Status: status, - Ctime: commontime.Time2String(item.CreateTime), - Mtime: commontime.Time2String(item.ModifyTime), + Id: item.ID, + Name: item.Type, + Type: item.Type, + Namespace: item.Namespace, + Service: item.Service, + Protocol: item.Protocol, + Version: item.Version, + Revision: item.Revision, + Content: item.Content, + ContentDigest: item.ContentDigest, + Metadata: item.Metadata, + Interfaces: methods, + Status: status, + Ctime: commontime.Time2String(item.CreateTime), + Mtime: commontime.Time2String(item.ModifyTime), + } + if isBrief { + contract.Content = "" } if addErr := api.AddAnyDataIntoBatchQuery(out, contract); addErr != nil { log.Error("[Service][Contract] add service_contract as any data fail", @@ -222,15 +293,15 @@ func (s *Server) DeleteServiceContract(ctx context.Context, saveData, err := s.storage.GetServiceContract(contract.Id) if err != nil { log.Error("[Service][Contract] get save service_contract when delete", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } if saveData == nil { - return api.NewResponse(apimodel.Code_ExecuteSuccess) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, nil) } deleteData := &model.ServiceContract{ ID: contract.Id, - Type: utils.DefaultString(contract.Type, contract.Name), + Type: utils.DefaultString(contract.GetType(), contract.GetName()), Namespace: contract.Namespace, Service: contract.Service, Protocol: contract.Protocol, @@ -239,12 +310,12 @@ func (s *Server) DeleteServiceContract(ctx context.Context, if createErr := s.storage.DeleteServiceContract(deleteData); createErr != nil { log.Error("[Service][Contract] do delete from store", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, &model.EnrichServiceContract{ ServiceContract: deleteData, }, model.ODelete)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, &apiservice.ServiceContract{Id: contract.Id}) } func (s *Server) GetServiceContractVersions(ctx context.Context, filter map[string]string) *apiservice.BatchQueryResponse { @@ -257,24 +328,25 @@ func (s *Server) GetServiceContractVersions(ctx context.Context, filter map[stri ret, err := s.storage.ListVersions(ctx, serviceName, namespace) if err != nil { log.Error("[Service][Contract] list save service_contract versions", utils.RequestID(ctx), zap.Error(err)) - return api.NewBatchQueryResponse(store.StoreCode2APICode(err)) + return api.NewBatchQueryResponse(commonstore.StoreCode2APICode(err)) } - resp := api.NewBatchQueryResponse(apimodel.Code_ExecuteSuccess) resp.Data = make([]*anypb.Any, 0, len(ret)) for i := range ret { item := ret[i] if err := api.AddAnyDataIntoBatchQuery(resp, &apiservice.ServiceContract{ - Id: item.ID, - Name: item.Type, - Type: item.Type, - Namespace: item.Namespace, - Service: item.Service, - Version: item.Version, - Protocol: item.Protocol, - Revision: utils.NewUUID(), - Ctime: commontime.Time2String(item.CreateTime), - Mtime: commontime.Time2String(item.ModifyTime), + Id: item.ID, + Name: item.Type, + Type: item.Type, + Namespace: item.Namespace, + Service: item.Service, + Version: item.Version, + Protocol: item.Protocol, + Metadata: item.Metadata, + ContentDigest: item.ContentDigest, + Ctime: commontime.Time2String(item.CreateTime), + Mtime: commontime.Time2String(item.ModifyTime), + Revision: item.Revision, }); err != nil { log.Error("[Service][Contract] list all versions fail", utils.RequestID(ctx), zap.String("namespace", namespace), zap.String("service", serviceName), zap.Error(err)) @@ -282,6 +354,7 @@ func (s *Server) GetServiceContractVersions(ctx context.Context, filter map[stri } } resp.Amount = utils.NewUInt32Value(uint32(len(ret))) + resp.Size = utils.NewUInt32Value(uint32(len(ret))) return resp } @@ -289,14 +362,10 @@ func (s *Server) GetServiceContractVersions(ctx context.Context, filter map[stri func (s *Server) CreateServiceContractInterfaces(ctx context.Context, contract *apiservice.ServiceContract, source apiservice.InterfaceDescriptor_Source) *apiservice.Response { - if contract.Id == "" { - id, errRsp := utils.CheckContractTetrad(contract) - if errRsp != nil { - return errRsp - } - contract.Id = id + if errRsp := checkOperationServiceContractInterface(contract); errRsp != nil { + return errRsp } - + contract.Type = utils.DefaultString(contract.GetType(), contract.GetName()) createData := &model.EnrichServiceContract{ ServiceContract: &model.ServiceContract{ ID: contract.Id, @@ -304,6 +373,9 @@ func (s *Server) CreateServiceContractInterfaces(ctx context.Context, }, Interfaces: make([]*model.InterfaceDescriptor, 0, len(contract.Interfaces)), } + retContract := &apiservice.ServiceContract{Id: contract.Id} + var err error + interfaces := make(map[string]*model.InterfaceDescriptor, len(contract.Interfaces)) for _, item := range contract.Interfaces { interfaceId, errRsp := utils.CheckContractInterfaceTetrad(createData.ID, source, item) if errRsp != nil { @@ -311,45 +383,89 @@ func (s *Server) CreateServiceContractInterfaces(ctx context.Context, zap.String("err", errRsp.GetInfo().GetValue())) return errRsp } - createData.Interfaces = append(createData.Interfaces, &model.InterfaceDescriptor{ + interfaceDescriptor := &model.InterfaceDescriptor{ ID: interfaceId, ContractID: contract.Id, - Type: utils.DefaultString(item.Type, item.Name), + Namespace: contract.Namespace, + Service: contract.Service, + Protocol: contract.Protocol, + Version: contract.Version, + Type: contract.GetType(), Method: item.Method, Path: item.Path, Content: item.Content, Source: source, Revision: utils.NewUUID(), - }) + } + if interfaceDescriptor.ContentDigest, err = utils.BuildSha1Digest(interfaceDescriptor.Content); err != nil { + log.Error("[Service][Contract] do build content digest for create interface descriptor", utils.RequestID(ctx), zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + interfaces[interfaceId] = interfaceDescriptor + createData.Interfaces = append(createData.Interfaces, interfaceDescriptor) + retContract.Interfaces = append(retContract.Interfaces, &apiservice.InterfaceDescriptor{Id: interfaceId}) } + // 比较是否需要更新 + saveData, err := s.storage.GetServiceContract(contract.Id) + if err != nil { + log.Error("[Service][Contract] get save service_contract when add interfaces", utils.RequestID(ctx), zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + var needUpdate = false + if saveData != nil { + if len(saveData.Interfaces) != len(interfaces) { + needUpdate = true + } else { + for _, localInterface := range saveData.Interfaces { + if remoteInterface, ok := interfaces[localInterface.ID]; ok { + if localInterface.Type != contract.Type { + needUpdate = true + break + } + if localInterface.Content != remoteInterface.Content { + needUpdate = true + break + } + if len(localInterface.ContentDigest) == 0 && len(localInterface.Content) > 0 { + // 老版本接口，没有写入digest，这里需要覆盖写入 + needUpdate = true + break + } + } else { + needUpdate = true + break + } + } + } + } + + if !needUpdate { + return api.NewServiceContractResponse(apimodel.Code_NoNeedUpdate, nil) + } if err := s.storage.AddServiceContractInterfaces(createData); err != nil { log.Error("[Service][Contract] full replace service_contract interfaces", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, createData, model.OUpdate)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, retContract) } // AppendServiceContractInterfaces 追加服务契约详情 func (s *Server) AppendServiceContractInterfaces(ctx context.Context, contract *apiservice.ServiceContract, source apiservice.InterfaceDescriptor_Source) *apiservice.Response { - if contract.Id == "" { - id, errRsp := utils.CheckContractTetrad(contract) - if errRsp != nil { - return errRsp - } - contract.Id = id + if errRsp := checkOperationServiceContractInterface(contract); errRsp != nil { + return errRsp } - + contract.Type = utils.DefaultString(contract.GetType(), contract.GetName()) saveData, err := s.storage.GetServiceContract(contract.Id) if err != nil { log.Error("[Service][Contract] get save service_contract when append interfaces", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } if saveData == nil { - return api.NewResponse(apimodel.Code_NotFoundResource) + return api.NewServiceContractResponse(apimodel.Code_NotFoundResource, nil) } appendData := &model.EnrichServiceContract{ @@ -359,7 +475,7 @@ func (s *Server) AppendServiceContractInterfaces(ctx context.Context, }, Interfaces: make([]*model.InterfaceDescriptor, 0, len(contract.Interfaces)), } - + retContract := &apiservice.ServiceContract{Id: contract.Id} for _, item := range contract.Interfaces { interfaceId, errRsp := utils.CheckContractInterfaceTetrad(appendData.ID, source, item) if errRsp != nil { @@ -367,44 +483,51 @@ func (s *Server) AppendServiceContractInterfaces(ctx context.Context, zap.String("err", errRsp.GetInfo().GetValue())) return errRsp } - appendData.Interfaces = append(appendData.Interfaces, &model.InterfaceDescriptor{ + interfaceDescriptor := &model.InterfaceDescriptor{ ID: interfaceId, ContractID: contract.Id, - Type: utils.DefaultString(item.Type, item.Name), + Namespace: contract.Namespace, + Service: contract.Service, + Protocol: contract.Protocol, + Version: contract.Version, + Type: contract.GetType(), Method: item.Method, Path: item.Path, Content: item.Content, Source: source, Revision: utils.NewUUID(), - }) + } + if interfaceDescriptor.ContentDigest, err = utils.BuildSha1Digest(interfaceDescriptor.Content); err != nil { + log.Error("[Service][Contract] do build content digest for create interface descriptor", utils.RequestID(ctx), zap.Error(err)) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) + } + appendData.Interfaces = append(appendData.Interfaces, interfaceDescriptor) + retContract.Interfaces = append(retContract.Interfaces, &apiservice.InterfaceDescriptor{Id: interfaceId}) + } if err := s.storage.AppendServiceContractInterfaces(appendData); err != nil { log.Error("[Service][Contract] append service_contract interfaces", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, appendData, model.OUpdate)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, retContract) } // DeleteServiceContractInterfaces 删除服务契约详情 func (s *Server) DeleteServiceContractInterfaces(ctx context.Context, contract *apiservice.ServiceContract) *apiservice.Response { - if contract.Id == "" { - id, errRsp := utils.CheckContractTetrad(contract) - if errRsp != nil { - return errRsp - } - contract.Id = id + if errRsp := checkOperationServiceContractInterface(contract); errRsp != nil { + return errRsp } saveData, err := s.storage.GetServiceContract(contract.Id) if err != nil { log.Error("[Service][Contract] get save service_contract when delete interfaces", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } if saveData == nil { - return api.NewResponse(apimodel.Code_NotFoundResource) + return api.NewServiceContractResponse(apimodel.Code_NotFoundResource, nil) } deleteData := &model.EnrichServiceContract{ @@ -414,7 +537,7 @@ func (s *Server) DeleteServiceContractInterfaces(ctx context.Context, }, Interfaces: make([]*model.InterfaceDescriptor, 0, len(contract.Interfaces)), } - + retContract := &apiservice.ServiceContract{Id: contract.Id} for _, item := range contract.Interfaces { interfaceId, errRsp := utils.CheckContractInterfaceTetrad(deleteData.ID, apiservice.InterfaceDescriptor_Manual, item) if errRsp != nil { @@ -426,16 +549,88 @@ func (s *Server) DeleteServiceContractInterfaces(ctx context.Context, ID: interfaceId, ContractID: contract.Id, Method: item.Method, - Type: utils.DefaultString(item.Type, item.Name), Path: item.Path, + Type: utils.DefaultString(item.Type, contract.GetType()), }) + retContract.Interfaces = append(retContract.Interfaces, &apiservice.InterfaceDescriptor{Id: interfaceId}) } if err := s.storage.DeleteServiceContractInterfaces(deleteData); err != nil { log.Error("[Service][Contract] delete service_contract interfaces", utils.RequestID(ctx), zap.Error(err)) - return api.NewAnyDataResponse(store.StoreCode2APICode(err), nil) + return api.NewServiceContractResponse(commonstore.StoreCode2APICode(err), nil) } s.RecordHistory(ctx, serviceContractRecordEntry(ctx, contract, deleteData, model.ODelete)) - return api.NewAnyDataResponse(apimodel.Code_ExecuteSuccess, nil) + return api.NewServiceContractResponse(apimodel.Code_ExecuteSuccess, retContract) +} + +const ( + briefSearch = "brief" +) + +func (s *Server) GetServiceInterfaces(ctx context.Context, filter map[string]string) *apiservice.BatchQueryResponse { + out := api.NewBatchQueryResponse(apimodel.Code_ExecuteSuccess) + out.Amount = utils.NewUInt32Value(0) + out.Size = utils.NewUInt32Value(0) + + var isBrief = false + if bValue, ok := filter[briefSearch]; ok && strings.ToLower(bValue) == "true" { + isBrief = true + delete(filter, briefSearch) + } + + searchFilters := map[string]string{} + for k, v := range filter { + newK, ok := interfaceSearchFilters[k] + if !ok { + log.Error("[Server][Contract][Query] not allowed", zap.String("attribute", k), utils.RequestID(ctx)) + return api.NewBatchQueryResponseWithMsg(apimodel.Code_InvalidParameter, k+" is not allowed") + } + if v == "" { + continue + } + searchFilters[newK] = v + } + offset, limit, err := utils.ParseOffsetAndLimit(searchFilters) + if err != nil { + out = api.NewBatchQueryResponseWithMsg(apimodel.Code_InvalidParameter, err.Error()) + return out + } + + if _, ok := searchFilters["order_field"]; !ok { + searchFilters["order_field"] = "mtime" + } + if _, ok := searchFilters["order_type"]; !ok { + searchFilters["order_type"] = "desc" + } + + total, ret, err := s.storage.GetInterfaceDescriptors(ctx, searchFilters, offset, limit) + if err != nil { + log.Error("[Service][Contract] query service_contract interfaces fail", utils.RequestID(ctx), zap.Error(err)) + return api.NewBatchQueryResponse(commonstore.StoreCode2APICode(err)) + } + out.Amount = utils.NewUInt32Value(total) + out.Size = utils.NewUInt32Value(uint32(len(ret))) + for i := range ret { + if isBrief { + ret[i].Content = "" + } + if err := api.AddAnyDataIntoBatchQuery(out, ret[i].ToSpec()); err != nil { + log.Error("[Service][Contract] query service_contract interfaces fail", utils.RequestID(ctx), zap.Error(err)) + return api.NewBatchQueryResponse(apimodel.Code_ExecuteException) + } + } + return out +} + +func checkOperationServiceContractInterface(contract *apiservice.ServiceContract) *apiservice.Response { + if contract.Id != "" { + return nil + } + id, errRsp := utils.CheckContractTetrad(contract) + if errRsp != nil { + return errRsp + } + contract.Id = id + return nil } // serviceContractRecordEntry 生成服务的记录entry @@ -457,3 +652,16 @@ func serviceContractRecordEntry(ctx context.Context, req *apiservice.ServiceCont return entry } + +func checkBaseServiceContract(req *apiservice.ServiceContract) *apiservice.Response { + if err := utils.CheckResourceName(utils.NewStringValue(req.GetNamespace())); err != nil { + return api.NewResponse(apimodel.Code_InvalidNamespaceName) + } + if req.GetName() == "" && req.GetType() == "" { + return api.NewResponseWithMsg(apimodel.Code_BadRequest, "invalid service_contract name") + } + if req.GetProtocol() == "" { + return api.NewResponseWithMsg(apimodel.Code_BadRequest, "invalid service_contract protocol") + } + return nil +} diff --git a/store/boltdb/instance.go b/store/boltdb/instance.go index e97ecbeb2..68b69810c 100644 --- a/store/boltdb/instance.go +++ b/store/boltdb/instance.go @@ -516,7 +516,7 @@ func (i *instanceStore) GetMoreInstances(tx store.Tx, mtime time.Time, firstUpda dbTx, _ := tx.GetDelegateTx().(*bolt.Tx) - fields := []string{insFieldProto, insFieldServiceID, insFieldValid} + fields := []string{insFieldProto, insFieldServiceID, insFieldValid, insFieldModifyTime} svcIdMap := make(map[string]bool) for _, s := range serviceID { svcIdMap[s] = true @@ -532,25 +532,23 @@ func (i *instanceStore) GetMoreInstances(tx store.Tx, mtime time.Time, firstUpda return false } } - - insProto, ok := m[insFieldProto] - if !ok { - return false - } svcId, ok := m[insFieldServiceID] if !ok { return false } - ins := insProto.(*apiservice.Instance) - serviceId := svcId.(string) - insMtime, err := time.Parse("2006-01-02 15:04:05", ins.GetMtime().GetValue()) - if err != nil { - log.Errorf("[Store][boltdb] parse instance mtime error, %v", err) + serviceId := svcId.(string) + modifyTime, ok := m[insFieldModifyTime] + if !ok { return false } - if insMtime.Before(mtime) { + if t, ok := modifyTime.(time.Time); ok { + if t.Before(mtime) { + return false + } + } else { + log.Errorf("modifyTime is not a time.Time,modifyTime is %+v", modifyTime) return false } @@ -873,6 +871,7 @@ func initInstance(instance []*model.Instance) { } ins.Valid = true ins.ModifyTime = currT + ins.CreateTime = currT } } } diff --git a/store/boltdb/service_contract.go b/store/boltdb/service_contract.go index aac1da718..52b86e0ff 100644 --- a/store/boltdb/service_contract.go +++ b/store/boltdb/service_contract.go @@ -446,17 +446,18 @@ func (s *serviceContractStore) toModel(data *ServiceContract) *model.EnrichServi _ = json.Unmarshal([]byte(data.Interfaces), &interfaces) ret := &model.EnrichServiceContract{ ServiceContract: &model.ServiceContract{ - ID: data.ID, - Namespace: data.Namespace, - Service: data.Service, - Type: data.Type, - Protocol: data.Protocol, - Version: data.Version, - Revision: data.Revision, - Content: data.Content, - CreateTime: data.CreateTime, - ModifyTime: data.ModifyTime, - Valid: data.Valid, + ID: data.ID, + Namespace: data.Namespace, + Service: data.Service, + Type: data.Type, + Protocol: data.Protocol, + Version: data.Version, + Revision: data.Revision, + Content: data.Content, + ContentDigest: data.ContentDigest, + CreateTime: data.CreateTime, + ModifyTime: data.ModifyTime, + Valid: data.Valid, }, Interfaces: interfaces, } @@ -466,18 +467,19 @@ func (s *serviceContractStore) toModel(data *ServiceContract) *model.EnrichServi func (s *serviceContractStore) toStore(data *model.EnrichServiceContract) *ServiceContract { return &ServiceContract{ - ID: data.ID, - Namespace: data.Namespace, - Service: data.Service, - Type: data.Type, - Protocol: data.Protocol, - Version: data.Version, - Revision: data.Revision, - Content: data.Content, - Interfaces: utils.MustJson(data.Interfaces), - CreateTime: data.CreateTime, - ModifyTime: data.ModifyTime, - Valid: data.Valid, + ID: data.ID, + Namespace: data.Namespace, + Service: data.Service, + Type: data.Type, + Protocol: data.Protocol, + Version: data.Version, + Revision: data.Revision, + Content: data.Content, + ContentDigest: data.ContentDigest, + Interfaces: utils.MustJson(data.Interfaces), + CreateTime: data.CreateTime, + ModifyTime: data.ModifyTime, + Valid: data.Valid, } } @@ -497,6 +499,8 @@ type ServiceContract struct { Revision string // 额外描述 Content string + // 内容摘要 + ContentDigest string // 接口描述信息 Interfaces string // 创建时间 diff --git a/store/mysql/admin.go b/store/mysql/admin.go index 658c9d9cf..759771f67 100644 --- a/store/mysql/admin.go +++ b/store/mysql/admin.go @@ -134,7 +134,8 @@ func (l *leaderElectionStore) CompareAndSwapVersion(key string, curVersion int64 // CheckMtimeExpired check last modify time expired func (l *leaderElectionStore) CheckMtimeExpired(key string, leaseTime int32) (string, bool, error) { log.Debugf("[Store][database] check mtime expired (%s, %d)", key, leaseTime) - mainStr := "select leader, FROM_UNIXTIME(UNIX_TIMESTAMP(SYSDATE())) - mtime from leader_election where elect_key = ?" + mainStr := `select leader, UNIX_TIMESTAMP(SYSDATE()) - UNIX_TIMESTAMP(mtime) + from leader_election where elect_key = ?` var ( leader string diff --git a/store/mysql/scripts/delta/v1_18_1-v1_19_0.sql b/store/mysql/scripts/delta/v1_18_1-v1_19_0.sql index 04548adc0..03f964b47 100644 --- a/store/mysql/scripts/delta/v1_18_1-v1_19_0.sql +++ b/store/mysql/scripts/delta/v1_18_1-v1_19_0.sql @@ -56,4 +56,9 @@ CRAETE TABLE `auth_strategy_function` ( `strategy_id` VARCHAR(128) NOT NULL COMMENT 'strategy id', `function` VARCHAR(256) NOT NULL COMMENT 'server provider function name', PRIMARY KEY (`strategy_id`, `function`) -) ENGINE = InnoDB; \ No newline at end of file +) ENGINE = InnoDB; + +/* 服务契约元数据及摘要 */ +ALTER TABLE `service_contract` ADD COLUMN `metadata` TEXT COMMENT 'service_contract metadata'; +ALTER TABLE `service_contract` ADD COLUMN `content_digest` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '当前服务契约的内容摘要，用于比较内容'; +ALTER TABLE `service_contract_detail` ADD COLUMN `content_digest` VARCHAR(128) NOT NULL DEFAULT '' COMMENT '当前服务接口的内容摘要，用于比较内容'; \ No newline at end of file diff --git a/store/mysql/scripts/polaris_server.sql b/store/mysql/scripts/polaris_server.sql index f7a470a58..1c200ef8b 100644 --- a/store/mysql/scripts/polaris_server.sql +++ b/store/mysql/scripts/polaris_server.sql @@ -875,51 +875,54 @@ CREATE TABLE /* 服务契约表 */ CREATE TABLE service_contract ( - `id` VARCHAR(128) NOT NULL COMMENT '服务契约主键', - `type` VARCHAR(128) NOT NULL COMMENT '服务契约名称', - `namespace` VARCHAR(64) NOT NULL COMMENT '命名空间', - `service` VARCHAR(128) NOT NULL COMMENT '服务名称', - `protocol` VARCHAR(32) NOT NULL COMMENT '当前契约对应的协议信息 e.g. http/dubbo/grpc/thrift', - `version` VARCHAR(64) NOT NULL COMMENT '服务契约版本', - `revision` VARCHAR(128) NOT NULL COMMENT '当前服务契约的全部内容版本摘要', - `flag` TINYINT (4) DEFAULT 0 COMMENT '逻辑删除标志位 ， 0 位有效 ， 1 为逻辑删除', - `content` LONGTEXT COMMENT '描述信息', - `ctime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, - `mtime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, - -- 通过 服务 + 协议信息 + 契约版本 + 名称 进行一次 hash 计算，作为主键 - PRIMARY KEY (`id`), - -- 服务 + 协议信息 + 契约版本 + 辅助标签 必须保证唯一 - KEY ( - `namespace`, - `service`, - `type`, - `version`, - `protocol` + `id` VARCHAR(128) NOT NULL COMMENT '服务契约主键', + `type` VARCHAR(128) NOT NULL COMMENT '服务契约类型', + `namespace` VARCHAR(64) NOT NULL COMMENT '命名空间', + `service` VARCHAR(128) NOT NULL COMMENT '服务名称', + `protocol` VARCHAR(32) NOT NULL COMMENT '当前契约对应的协议信息 e.g. http/dubbo/grpc/thrift', + `version` VARCHAR(64) NOT NULL COMMENT '服务契约版本', + `revision` VARCHAR(128) NOT NULL COMMENT '当前服务契约的全部内容版本摘要', + `flag` TINYINT(4) DEFAULT 0 COMMENT '逻辑删除标志位 ， 0 位有效 ， 1 为逻辑删除', + `content` LONGTEXT COMMENT '描述信息', + `ctime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + `mtime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + `metadata` TEXT COMMENT 'service_contract metadata', + `content_digest` VARCHAR(128) NOT NULL COMMENT '当前服务契约的内容摘要，用于比较内容', + -- 通过 服务 + 协议信息 + 契约版本 + 名称 进行一次 hash 计算，作为主键 + PRIMARY KEY (`id`), + -- 服务 + 协议信息 + 契约版本 + 辅助标签 必须保证唯一 + UNIQUE KEY ( + `namespace`, + `service`, + `type`, + `version`, + `protocol` ) - ) ENGINE = InnoDB; +) ENGINE = InnoDB; /* 服务契约中针对单个接口定义的详细信息描述表 */ CREATE TABLE service_contract_detail ( - `id` VARCHAR(128) NOT NULL COMMENT '服务契约单个接口定义记录主键', - `contract_id` VARCHAR(128) NOT NULL COMMENT '服务契约 ID', - `type` VARCHAR(128) NOT NULL COMMENT '服务契约接口名称', - `namespace` VARCHAR(64) NOT NULL COMMENT '命名空间', - `service` VARCHAR(128) NOT NULL COMMENT '服务名称', - `protocol` VARCHAR(32) NOT NULL COMMENT '当前契约对应的协议信息 e.g. http/dubbo/grpc/thrift', - `version` VARCHAR(64) NOT NULL COMMENT '服务契约版本', - `method` VARCHAR(32) NOT NULL COMMENT 'http协议中的 method 字段, eg:POST/GET/PUT/DELETE, 其他 gRPC 可以用来标识 stream 类型', - `path` VARCHAR(128) NOT NULL COMMENT '接口具体全路径描述', - `source` INT COMMENT '该条记录来源, 0:SDK/1:MANUAL', - `content` LONGTEXT COMMENT '描述信息', - `revision` VARCHAR(128) NOT NULL COMMENT '当前接口定义的全部内容版本摘要', - `flag` TINYINT (4) DEFAULT 0 COMMENT '逻辑删除标志位, 0 位有效, 1 为逻辑删除', - `ctime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, - `mtime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, - PRIMARY KEY (`id`), - -- 服务契约id + method + path + source 需保证唯一 - KEY (`contract_id`, `path`, `method`, `source`) - ) ENGINE = InnoDB; + `id` VARCHAR(128) NOT NULL COMMENT '服务契约单个接口定义记录主键', + `contract_id` VARCHAR(128) NOT NULL COMMENT '服务契约 ID', + `namespace` VARCHAR(64) NOT NULL COMMENT '命名空间', + `service` VARCHAR(128) NOT NULL COMMENT '服务名称', + `protocol` VARCHAR(32) NOT NULL COMMENT '当前契约对应的协议信息 e.g. http/dubbo/grpc/thrift', + `version` VARCHAR(64) NOT NULL COMMENT '服务契约版本', + `type` VARCHAR(128) NOT NULL COMMENT '类型', + `method` VARCHAR(32) NOT NULL COMMENT 'http协议中的 method 字段, eg:POST/GET/PUT/DELETE, 其他 gRPC 可以用来标识 stream 类型', + `path` VARCHAR(128) NOT NULL COMMENT '接口具体全路径描述', + `source` INT COMMENT '该条记录来源, 0:SDK/1:MANUAL', + `content` LONGTEXT COMMENT '描述信息', + `revision` VARCHAR(128) NOT NULL COMMENT '当前接口定义的全部内容版本摘要', + `flag` TINYINT(4) DEFAULT 0 COMMENT '逻辑删除标志位, 0 位有效, 1 为逻辑删除', + `ctime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + `mtime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + `content_digest` VARCHAR(128) NOT NULL COMMENT '当前服务接口的内容摘要，用于比较内容', + PRIMARY KEY (`id`), + -- 服务契约id + method + path + source 需保证唯一 + KEY (`contract_id`, `path`, `method`, `source`) +) ENGINE = InnoDB; /* 灰度资源 */ CREATE TABLE diff --git a/store/mysql/service.go b/store/mysql/service.go index e7e7bde00..cc30163a9 100644 --- a/store/mysql/service.go +++ b/store/mysql/service.go @@ -1050,7 +1050,6 @@ func callFetchServiceRows(rows *sql.Rows, callback func(entry *model.Service) (b } defer rows.Close() - var ctime, mtime int64 var flag int progress := 0 for rows.Next() { @@ -1063,7 +1062,7 @@ func callFetchServiceRows(rows *sql.Rows, callback func(entry *model.Service) (b var exportTo string err := rows.Scan( &item.ID, &item.Name, &item.Namespace, &item.Business, &item.Comment, - &item.Token, &item.Revision, &item.Owner, &flag, &ctime, &mtime, &item.Ports, + &item.Token, &item.Revision, &item.Owner, &flag, &item.Ctime, &item.Mtime, &item.Ports, &item.Department, &item.CmdbMod1, &item.CmdbMod2, &item.CmdbMod3, &item.Reference, &item.ReferFilter, &item.PlatformID, &exportTo) @@ -1072,8 +1071,8 @@ func callFetchServiceRows(rows *sql.Rows, callback func(entry *model.Service) (b return err } - item.CreateTime = time.Unix(ctime, 0) - item.ModifyTime = time.Unix(mtime, 0) + item.CreateTime = time.Unix(item.Ctime, 0) + item.ModifyTime = time.Unix(item.Mtime, 0) item.ExportTo = map[string]struct{}{} _ = json.Unmarshal([]byte(exportTo), &item.ExportTo) item.Valid = true diff --git a/store/mysql/service_contract.go b/store/mysql/service_contract.go index 5daca1428..764244920 100644 --- a/store/mysql/service_contract.go +++ b/store/mysql/service_contract.go @@ -40,8 +40,8 @@ type serviceContractStore struct { // CreateServiceContract 创建服务契约 func (s *serviceContractStore) CreateServiceContract(contract *model.ServiceContract) error { addSql := "INSERT INTO service_contract(`id`,`type`, `namespace`, `service`, `protocol`,`version`, " + - " `revision`, `flag`, `content`, `ctime`, `mtime`" + - ") VALUES (?,?,?,?,?,?,?,0,?,sysdate(),sysdate())" + " `revision`, `flag`, `content`, `content_digest`, `metadata`, `ctime`, `mtime`" + + ") VALUES (?,?,?,?,?,?,?,0,?,?,?,sysdate(),sysdate())" _, err := s.master.Exec(addSql, []interface{}{ contract.ID, @@ -52,14 +52,18 @@ func (s *serviceContractStore) CreateServiceContract(contract *model.ServiceCont contract.Version, contract.Revision, contract.Content, + contract.ContentDigest, + contract.MetadataStr, }...) return store.Error(err) } // UpdateServiceContract 更新服务契约信息 func (s *serviceContractStore) UpdateServiceContract(contract *model.ServiceContract) error { - updateSql := "UPDATE service_contract SET content = ?, revision = ?, mtime = sysdate() WHERE id = ?" - _, err := s.master.Exec(updateSql, contract.Content, contract.Revision, contract.ID) + updateSql := "UPDATE service_contract SET content = ?, content_digest = ?, metadata = ?, revision = ?, " + + "mtime = sysdate() WHERE id = ?" + _, err := s.master.Exec(updateSql, contract.Content, contract.ContentDigest, contract.MetadataStr, + contract.Revision, contract.ID) if err != nil { return err } @@ -91,8 +95,8 @@ func (s *serviceContractStore) DeleteServiceContract(contract *model.ServiceCont // GetServiceContract 通过ID查询服务契约数据 func (s *serviceContractStore) GetServiceContract(id string) (*model.EnrichServiceContract, error) { - querySql := "SELECT id, type, namespace, service, protocol, version, revision, flag, content, " + - " UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) FROM service_contract WHERE flag = 0 AND id = ?" + querySql := "SELECT id, type, namespace, service, protocol, version, revision, flag, content, content_digest, " + + " IFNULL(metadata, ''), UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) FROM service_contract WHERE flag = 0 AND id = ?" args := []interface{}{id} @@ -113,8 +117,8 @@ func (s *serviceContractStore) GetServiceContract(id string) (*model.EnrichServi for i := range list { contract := list[i] - queryDetailSql := "SELECT id, contract_id, namespace, service, protocol, version, type, method, path, content, revision, " + - " UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime), IFNULL(source, 1) " + + queryDetailSql := "SELECT id, contract_id, namespace, service, protocol, version, type, method, path, content, " + + "content_digest, revision, UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime), IFNULL(source, 1) " + " FROM service_contract_detail " + " WHERE contract_id = ?" @@ -150,14 +154,15 @@ func transferEnrichServiceContract(rows *sql.Rows, consumer func(contract *model } if scanErr := rows.Scan(&contract.ID, &contract.Type, &contract.Namespace, &contract.Service, &contract.Protocol, &contract.Version, &contract.Revision, &flag, - &contract.Content, &ctime, &mtime); scanErr != nil { + &contract.Content, &contract.ContentDigest, &contract.MetadataStr, &ctime, &mtime); scanErr != nil { log.Errorf("[Store][Contract] fetch contract rows scan err: %s", scanErr.Error()) return scanErr } contract.Valid = flag == 0 - contract.CreateTime = time.Unix(0, ctime) - contract.ModifyTime = time.Unix(0, mtime) + contract.CreateTime = time.Unix(ctime, 0) + contract.ModifyTime = time.Unix(mtime, 0) + contract.Metadata, _ = utils.ConvertStringValueToMetadata(contract.MetadataStr) consumer(&contract) } return nil @@ -172,11 +177,18 @@ func (s *serviceContractStore) AddServiceContractInterfaces(contract *model.Enri return err } + deleteSql := "DELETE FROM service_contract_detail WHERE contract_id = ?" + if _, err := tx.Exec(deleteSql, []interface{}{contract.ID}...); err != nil { + log.Errorf("[Store][database] delete service contract detail for contract %s revision err: %s", + contract.ID, err.Error()) + return err + } + // 新增批量数据 for _, item := range contract.Interfaces { addSql := "REPLACE INTO service_contract_detail (id, contract_id, namespace, service, protocol, " + - " version, method, path, type, content, revision, flag, ctime, mtime, source) " + - " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, sysdate(), sysdate(), ?)" + " version, method, path, type, content, content_digest, revision, flag, ctime, mtime, source) " + + " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, sysdate(), sysdate(), ?)" if _, err := tx.Exec(addSql, []interface{}{ item.ID, contract.ID, @@ -188,6 +200,7 @@ func (s *serviceContractStore) AddServiceContractInterfaces(contract *model.Enri item.Path, item.Type, item.Content, + item.ContentDigest, item.Revision, 0, int(item.Source), @@ -210,9 +223,9 @@ func (s *serviceContractStore) AppendServiceContractInterfaces(contract *model.E } for _, item := range contract.Interfaces { addSql := "REPLACE INTO service_contract_detail(`id`,`contract_id`, `namespace`, `service`, " + - " `protocol`, `version`, `method`, `path`, `type` ,`content`,`revision`" + + " `protocol`, `version`, `method`, `path`, `type` ,`content`, `content_digest`, `revision`" + ",`flag`,`ctime`, `mtime`,`source`" + - ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,sysdate(),sysdate(),?)" + ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,sysdate(),sysdate(),?)" if _, err := tx.Exec(addSql, []interface{}{ item.ID, @@ -225,6 +238,7 @@ func (s *serviceContractStore) AppendServiceContractInterfaces(contract *model.E item.Path, item.Type, item.Content, + item.ContentDigest, item.Revision, 0, int(item.Source), @@ -247,13 +261,21 @@ func (s *serviceContractStore) DeleteServiceContractInterfaces(contract *model.E } for _, item := range contract.Interfaces { addSql := "UPDATE service_contract_detail SET flag = 1 WHERE contract_id = ? AND method = ? AND path = ? AND type = ?" - - if _, err := tx.Exec(addSql, []interface{}{ + args := []interface{}{ item.ContractID, item.Method, item.Path, item.Type, - }...); err != nil { + } + if item.ID != "" { + addSql = "UPDATE service_contract_detail SET flag = 1 WHERE contract_id = ? AND id = ?" + args = []interface{}{ + item.ContractID, + item.ID, + } + } + + if _, err := tx.Exec(addSql, args...); err != nil { log.Errorf("[Store][database] delete service contract detail err: %s", err.Error()) return err } @@ -273,16 +295,17 @@ func (s *serviceContractStore) GetServiceContracts(ctx context.Context, filter m } querySql := ` - SELECT id, type, namespace, service, protocol - , version, revision, flag, content - , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) - FROM service_contract - WHERE flag = 0 - ` +SELECT id, type, namespace, service, protocol + , version, revision, flag, content, content_digest, IFNULL(metadata, '') + , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) +FROM service_contract +WHERE flag = 0 +` countSql := "SELECT COUNT(*) FROM service_contract WHERE flag = 0 " brief := filter[briefSearch] == "true" + delete(filter, briefSearch) args := make([]interface{}, 0, len(filter)) conditions := make([]string, 0, len(filter)) for k, v := range filter { @@ -315,6 +338,7 @@ func (s *serviceContractStore) GetServiceContracts(ctx context.Context, filter m } args = append(args, offset, limit) + // NOCA:yunding/go/sql-injection(非SQL注入问题) rows, err := tx.Query(querySql, args...) if err != nil { log.Error("[Store][Contract] list service_contracts", zap.String("query", querySql), zap.Any("args", args), zap.Error(err)) @@ -324,7 +348,7 @@ func (s *serviceContractStore) GetServiceContracts(ctx context.Context, filter m _ = rows.Close() }() - contractIds := make([]interface{}, 0, 32) + contractIds := make([]interface{}, 0, limit) err = transferEnrichServiceContract(rows, func(contract *model.EnrichServiceContract) { list = append(list, contract) contractIds = append(contractIds, contract.ID) @@ -337,7 +361,7 @@ func (s *serviceContractStore) GetServiceContracts(ctx context.Context, filter m if !brief && len(contractIds) > 0 { // 加载 interfaces 列表 queryDetailSql := fmt.Sprintf("SELECT id, contract_id, namespace, service, protocol, version, "+ - " type, method, path, content, revision, "+ + " type, method, path, content, content_digest, revision, "+ " UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime), IFNULL(source, 1) "+ " FROM service_contract_detail "+ " WHERE contract_id IN (%s)", placeholders(len(contractIds))) @@ -376,13 +400,13 @@ func (s *serviceContractStore) GetInterfaceDescriptors(ctx context.Context, filt // 加载 interfaces 列表 querySql := ` - SELECT id, contract_id, namespace, service, protocol, version - , type, method, path, content, revision - , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) - , IFNULL(source, 1) - FROM service_contract_detail - WHERE flag = 0 - ` +SELECT id, contract_id, namespace, service, protocol, version + , type, method, path, content, content_digest, revision + , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) + , IFNULL(source, 1) +FROM service_contract_detail +WHERE flag = 0 +` args := make([]interface{}, 0, len(filter)) conditions := make([]string, 0, len(filter)) @@ -391,7 +415,12 @@ func (s *serviceContractStore) GetInterfaceDescriptors(ctx context.Context, filt if k == "order_field" || k == "order_type" { continue } - conditions = append(conditions, k+" = ? ") + if utils.IsWildName(v) { + conditions = append(conditions, k+" LIKE ? ") + v = utils.ParseWildNameForSql(v) + } else { + conditions = append(conditions, k+" = ? ") + } args = append(args, v) } @@ -440,11 +469,11 @@ func (s *serviceContractStore) loadContractInterfaces(tx *BaseTx, query string, if scanErr := rows.Scan( &detailItem.ID, &detailItem.ContractID, &detailItem.Namespace, &detailItem.Service, &detailItem.Protocol, &detailItem.Version, &detailItem.Type, &detailItem.Method, - &detailItem.Path, &detailItem.Content, &detailItem.Revision, + &detailItem.Path, &detailItem.Content, &detailItem.ContentDigest, &detailItem.Revision, &ctime, &mtime, &source, ); scanErr != nil { log.Error("[Store][Contract] load service_contract interface rows scan", zap.Error(scanErr)) - return nil, err + return nil, scanErr } detailItem.Valid = flag == 0 @@ -467,12 +496,12 @@ func (s *serviceContractStore) ListVersions(ctx context.Context, service, namesp list := make([]*model.ServiceContract, 0, 4) querySql := ` - SELECT id, type, namespace, service, protocol - , version, revision, flag, content - , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) - FROM service_contract - WHERE flag = 0 AND namespace = ? AND service = ? - ` +SELECT id, type, namespace, service, protocol + , version, revision, flag, content, content_digest, IFNULL(metadata, '') + , UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) +FROM service_contract +WHERE flag = 0 AND namespace = ? AND service = ? +` rows, err := s.slave.Query(querySql, namespace, service) if err != nil { @@ -493,8 +522,8 @@ func (s *serviceContractStore) ListVersions(ctx context.Context, service, namesp // GetMoreServiceContracts . func (s *serviceContractStore) GetMoreServiceContracts(firstUpdate bool, mtime time.Time) ([]*model.EnrichServiceContract, error) { - querySql := "SELECT id, type, namespace, service, protocol, version, revision, flag, content, " + - " UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) FROM service_contract WHERE mtime >= ? " + querySql := "SELECT id, type, namespace, service, protocol, version, revision, flag, content, content_digest, " + + "IFNULL(metadata, ''), UNIX_TIMESTAMP(ctime), UNIX_TIMESTAMP(mtime) FROM service_contract WHERE mtime >= ? " if firstUpdate { mtime = time.Unix(0, 1) querySql += " AND flag = 0 " @@ -524,7 +553,7 @@ func (s *serviceContractStore) GetMoreServiceContracts(firstUpdate bool, mtime t contract := &model.ServiceContract{} if scanErr := rows.Scan(&contract.ID, &contract.Type, &contract.Namespace, &contract.Service, &contract.Protocol, &contract.Version, &contract.Revision, &flag, - &contract.Content, &ctime, &mtime); scanErr != nil { + &contract.Content, &contract.ContentDigest, &contract.MetadataStr, &ctime, &mtime); scanErr != nil { log.Error("[Store][Contract] fetch contract rows scan err: %s", zap.Error(err)) return nil, store.Error(err) } @@ -532,6 +561,7 @@ func (s *serviceContractStore) GetMoreServiceContracts(firstUpdate bool, mtime t contract.Valid = flag == 0 contract.CreateTime = time.Unix(ctime, 0) contract.ModifyTime = time.Unix(mtime, 0) + contract.Metadata, _ = utils.ConvertStringValueToMetadata(contract.MetadataStr) list = append(list, &model.EnrichServiceContract{ ServiceContract: contract, @@ -540,8 +570,8 @@ func (s *serviceContractStore) GetMoreServiceContracts(firstUpdate bool, mtime t contractDetailMap := map[string][]*model.InterfaceDescriptor{} if len(list) > 0 { - queryDetailSql := "SELECT sd.id, sd.contract_id, sd.type, sd.method, sd.path, sd.content, sd.revision, " + - " UNIX_TIMESTAMP(sd.ctime), UNIX_TIMESTAMP(sd.mtime), IFNULL(sd.source, 1) " + + queryDetailSql := "SELECT sd.id, sd.contract_id, sd.type, sd.method, sd.path, sd.content, sd.content_digest, " + + "sd.revision, UNIX_TIMESTAMP(sd.ctime), UNIX_TIMESTAMP(sd.mtime), IFNULL(sd.source, 1) " + " FROM service_contract_detail sd LEFT JOIN service_contract sc ON sd.contract_id = sc.id " + " WHERE sc.mtime >= ?" detailRows, err := tx.Query(queryDetailSql, mtime) @@ -557,7 +587,7 @@ func (s *serviceContractStore) GetMoreServiceContracts(firstUpdate bool, mtime t detailItem := &model.InterfaceDescriptor{} if scanErr := detailRows.Scan( &detailItem.ID, &detailItem.ContractID, &detailItem.Type, &detailItem.Method, - &detailItem.Path, &detailItem.Content, &detailItem.Revision, + &detailItem.Path, &detailItem.Content, &detailItem.ContentDigest, &detailItem.Revision, &ctime, &mtime, &source, ); scanErr != nil { log.Error("[Store][Contract] fetch contract detail rows scan", zap.Error(scanErr))