repo

package

Go to main page

Versions in this module

v0

v0.6.1

Jan 13, 2025

v0.6.0

Nov 25, 2024

v0.5.0

Nov 16, 2024

v0.4.0

Nov 10, 2024

v0.3.0

Nov 4, 2024

v0.2.0

Oct 28, 2024

Changes in this version

type BackendConfig

+ Method string

+ Name string

+ URLTemplate string

type CallsRepository

+ func (r *CallsRepository) UpdateCalls(calls *CallsConfig)

type Etcd

+ Close func() error

+ Watch func(key string) (clientv3.WatchChan, context.CancelFunc)

type EtcdHandler

+ func (etcdHandler *EtcdHandler) Close() error

+ func (etcdHandler *EtcdHandler) Watch(key string) (clientv3.WatchChan, context.CancelFunc)

type MockEtcd

+ func (_m *MockEtcd) Close() error

+ func (_m *MockEtcd) Watch(key string) (clientv3.WatchChan, context.CancelFunc)

+ type MockEtcd_Close_Call struct

+ func (_c *MockEtcd_Close_Call) Return(_a0 error) *MockEtcd_Close_Call

+ func (_c *MockEtcd_Close_Call) Run(run func()) *MockEtcd_Close_Call

+ func (_c *MockEtcd_Close_Call) RunAndReturn(run func() error) *MockEtcd_Close_Call

type MockEtcd_Expecter

+ func (_e *MockEtcd_Expecter) Close() *MockEtcd_Close_Call

+ func (_e *MockEtcd_Expecter) Watch(key interface{}) *MockEtcd_Watch_Call

+ type MockEtcd_Watch_Call struct

+ func (_c *MockEtcd_Watch_Call) Return(_a0 clientv3.WatchChan, _a1 context.CancelFunc) *MockEtcd_Watch_Call

+ func (_c *MockEtcd_Watch_Call) Run(run func(key string)) *MockEtcd_Watch_Call

+ func (_c *MockEtcd_Watch_Call) RunAndReturn(run func(string) (clientv3.WatchChan, context.CancelFunc)) *MockEtcd_Watch_Call

v0.1.0

Oct 21, 2024

Changes in this version

type BackendConfig

+ DependsOn []string

+ type Etcd interface

+ Client func(cfg EtcdConfig) (*clientv3.Client, error)

+ Put func(ctx context.Context, cli *clientv3.Client, key string, value string) error

+ func NewEtcdHandler(etcdConfig EtcdConfig) Etcd

+ type EtcdConfig struct

+ DialTimeoutSeconds int

+ Servers []string

+ type EtcdHandler struct

+ Conf *clientv3.Config

+ func (etcdHandler EtcdHandler) Client(cfg EtcdConfig) (*clientv3.Client, error)

+ func (etcdHandler EtcdHandler) Put(ctx context.Context, cli *clientv3.Client, key, value string) error

+ type MockEtcd struct

+ func NewMockEtcd(t interface{ ... }) *MockEtcd

+ func (_m *MockEtcd) Client(cfg EtcdConfig) (*clientv3.Client, error)

+ func (_m *MockEtcd) EXPECT() *MockEtcd_Expecter

+ func (_m *MockEtcd) Put(ctx context.Context, cli *clientv3.Client, key string, value string) error

+ type MockEtcd_Client_Call struct

+ func (_c *MockEtcd_Client_Call) Return(_a0 *clientv3.Client, _a1 error) *MockEtcd_Client_Call

+ func (_c *MockEtcd_Client_Call) Run(run func(cfg EtcdConfig)) *MockEtcd_Client_Call

+ func (_c *MockEtcd_Client_Call) RunAndReturn(run func(EtcdConfig) (*clientv3.Client, error)) *MockEtcd_Client_Call

+ type MockEtcd_Expecter struct

+ func (_e *MockEtcd_Expecter) Client(cfg interface{}) *MockEtcd_Client_Call

+ func (_e *MockEtcd_Expecter) Put(ctx interface{}, cli interface{}, key interface{}, value interface{}) *MockEtcd_Put_Call

+ type MockEtcd_Put_Call struct

+ func (_c *MockEtcd_Put_Call) Return(_a0 error) *MockEtcd_Put_Call

+ func (_c *MockEtcd_Put_Call) Run(run func(ctx context.Context, cli *clientv3.Client, key string, value string)) *MockEtcd_Put_Call

+ func (_c *MockEtcd_Put_Call) RunAndReturn(run func(context.Context, *clientv3.Client, string, string) error) *MockEtcd_Put_Call

+ type MockKV struct

+ func NewMockKV(t interface{ ... }) *MockKV

+ func (_m *MockKV) Compact(ctx context.Context, rev int64, opts ...clientv3.CompactOption) (*clientv3.CompactResponse, error)

+ func (_m *MockKV) Delete(ctx context.Context, key string, opts ...clientv3.OpOption) (*clientv3.DeleteResponse, error)

+ func (_m *MockKV) Do(ctx context.Context, op clientv3.Op) (clientv3.OpResponse, error)

+ func (_m *MockKV) EXPECT() *MockKV_Expecter

+ func (_m *MockKV) Get(ctx context.Context, key string, opts ...clientv3.OpOption) (*clientv3.GetResponse, error)

+ func (_m *MockKV) Put(ctx context.Context, key string, val string, opts ...clientv3.OpOption) (*clientv3.PutResponse, error)

+ func (_m *MockKV) Txn(ctx context.Context) clientv3.Txn

+ type MockKV_Compact_Call struct

+ func (_c *MockKV_Compact_Call) Return(_a0 *clientv3.CompactResponse, _a1 error) *MockKV_Compact_Call

+ func (_c *MockKV_Compact_Call) Run(run func(ctx context.Context, rev int64, opts ...clientv3.CompactOption)) *MockKV_Compact_Call

+ func (_c *MockKV_Compact_Call) RunAndReturn(...) *MockKV_Compact_Call

+ type MockKV_Delete_Call struct

+ func (_c *MockKV_Delete_Call) Return(_a0 *clientv3.DeleteResponse, _a1 error) *MockKV_Delete_Call

+ func (_c *MockKV_Delete_Call) Run(run func(ctx context.Context, key string, opts ...clientv3.OpOption)) *MockKV_Delete_Call

+ func (_c *MockKV_Delete_Call) RunAndReturn(...) *MockKV_Delete_Call

+ type MockKV_Do_Call struct

+ func (_c *MockKV_Do_Call) Return(_a0 clientv3.OpResponse, _a1 error) *MockKV_Do_Call

+ func (_c *MockKV_Do_Call) Run(run func(ctx context.Context, op clientv3.Op)) *MockKV_Do_Call

+ func (_c *MockKV_Do_Call) RunAndReturn(run func(context.Context, clientv3.Op) (clientv3.OpResponse, error)) *MockKV_Do_Call

+ type MockKV_Expecter struct

+ func (_e *MockKV_Expecter) Compact(ctx interface{}, rev interface{}, opts ...interface{}) *MockKV_Compact_Call

+ func (_e *MockKV_Expecter) Delete(ctx interface{}, key interface{}, opts ...interface{}) *MockKV_Delete_Call

+ func (_e *MockKV_Expecter) Do(ctx interface{}, op interface{}) *MockKV_Do_Call

+ func (_e *MockKV_Expecter) Get(ctx interface{}, key interface{}, opts ...interface{}) *MockKV_Get_Call

+ func (_e *MockKV_Expecter) Put(ctx interface{}, key interface{}, val interface{}, opts ...interface{}) *MockKV_Put_Call

+ func (_e *MockKV_Expecter) Txn(ctx interface{}) *MockKV_Txn_Call

+ type MockKV_Get_Call struct

+ func (_c *MockKV_Get_Call) Return(_a0 *clientv3.GetResponse, _a1 error) *MockKV_Get_Call

+ func (_c *MockKV_Get_Call) Run(run func(ctx context.Context, key string, opts ...clientv3.OpOption)) *MockKV_Get_Call

+ func (_c *MockKV_Get_Call) RunAndReturn(...) *MockKV_Get_Call

+ type MockKV_Put_Call struct

+ func (_c *MockKV_Put_Call) Return(_a0 *clientv3.PutResponse, _a1 error) *MockKV_Put_Call

+ func (_c *MockKV_Put_Call) Run(...) *MockKV_Put_Call

+ func (_c *MockKV_Put_Call) RunAndReturn(...) *MockKV_Put_Call

+ type MockKV_Txn_Call struct

+ func (_c *MockKV_Txn_Call) Return(_a0 clientv3.Txn) *MockKV_Txn_Call

+ func (_c *MockKV_Txn_Call) Run(run func(ctx context.Context)) *MockKV_Txn_Call

+ func (_c *MockKV_Txn_Call) RunAndReturn(run func(context.Context) clientv3.Txn) *MockKV_Txn_Call

+ type MockLease struct

+ func NewMockLease(t interface{ ... }) *MockLease

+ func (_m *MockLease) Close() error

+ func (_m *MockLease) EXPECT() *MockLease_Expecter

+ func (_m *MockLease) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseGrantResponse, error)

+ func (_m *MockLease) KeepAlive(ctx context.Context, id clientv3.LeaseID) (<-chan *clientv3.LeaseKeepAliveResponse, error)

+ func (_m *MockLease) KeepAliveOnce(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseKeepAliveResponse, error)

+ func (_m *MockLease) Leases(ctx context.Context) (*clientv3.LeaseLeasesResponse, error)

+ func (_m *MockLease) Revoke(ctx context.Context, id clientv3.LeaseID) (*clientv3.LeaseRevokeResponse, error)

+ func (_m *MockLease) TimeToLive(ctx context.Context, id clientv3.LeaseID, opts ...clientv3.LeaseOption) (*clientv3.LeaseTimeToLiveResponse, error)

+ type MockLease_Close_Call struct

+ func (_c *MockLease_Close_Call) Return(_a0 error) *MockLease_Close_Call

+ func (_c *MockLease_Close_Call) Run(run func()) *MockLease_Close_Call

+ func (_c *MockLease_Close_Call) RunAndReturn(run func() error) *MockLease_Close_Call

+ type MockLease_Expecter struct

+ func (_e *MockLease_Expecter) Close() *MockLease_Close_Call

+ func (_e *MockLease_Expecter) Grant(ctx interface{}, ttl interface{}) *MockLease_Grant_Call

+ func (_e *MockLease_Expecter) KeepAlive(ctx interface{}, id interface{}) *MockLease_KeepAlive_Call

+ func (_e *MockLease_Expecter) KeepAliveOnce(ctx interface{}, id interface{}) *MockLease_KeepAliveOnce_Call

+ func (_e *MockLease_Expecter) Leases(ctx interface{}) *MockLease_Leases_Call

+ func (_e *MockLease_Expecter) Revoke(ctx interface{}, id interface{}) *MockLease_Revoke_Call

+ func (_e *MockLease_Expecter) TimeToLive(ctx interface{}, id interface{}, opts ...interface{}) *MockLease_TimeToLive_Call

+ type MockLease_Grant_Call struct

+ func (_c *MockLease_Grant_Call) Return(_a0 *clientv3.LeaseGrantResponse, _a1 error) *MockLease_Grant_Call

+ func (_c *MockLease_Grant_Call) Run(run func(ctx context.Context, ttl int64)) *MockLease_Grant_Call

+ func (_c *MockLease_Grant_Call) RunAndReturn(run func(context.Context, int64) (*clientv3.LeaseGrantResponse, error)) *MockLease_Grant_Call

+ type MockLease_KeepAliveOnce_Call struct

+ func (_c *MockLease_KeepAliveOnce_Call) Return(_a0 *clientv3.LeaseKeepAliveResponse, _a1 error) *MockLease_KeepAliveOnce_Call

+ func (_c *MockLease_KeepAliveOnce_Call) Run(run func(ctx context.Context, id clientv3.LeaseID)) *MockLease_KeepAliveOnce_Call

+ func (_c *MockLease_KeepAliveOnce_Call) RunAndReturn(...) *MockLease_KeepAliveOnce_Call

+ type MockLease_KeepAlive_Call struct

+ func (_c *MockLease_KeepAlive_Call) Return(_a0 <-chan *clientv3.LeaseKeepAliveResponse, _a1 error) *MockLease_KeepAlive_Call

+ func (_c *MockLease_KeepAlive_Call) Run(run func(ctx context.Context, id clientv3.LeaseID)) *MockLease_KeepAlive_Call

+ func (_c *MockLease_KeepAlive_Call) RunAndReturn(...) *MockLease_KeepAlive_Call

+ type MockLease_Leases_Call struct

+ func (_c *MockLease_Leases_Call) Return(_a0 *clientv3.LeaseLeasesResponse, _a1 error) *MockLease_Leases_Call

+ func (_c *MockLease_Leases_Call) Run(run func(ctx context.Context)) *MockLease_Leases_Call

+ func (_c *MockLease_Leases_Call) RunAndReturn(run func(context.Context) (*clientv3.LeaseLeasesResponse, error)) *MockLease_Leases_Call

+ type MockLease_Revoke_Call struct

+ func (_c *MockLease_Revoke_Call) Return(_a0 *clientv3.LeaseRevokeResponse, _a1 error) *MockLease_Revoke_Call

+ func (_c *MockLease_Revoke_Call) Run(run func(ctx context.Context, id clientv3.LeaseID)) *MockLease_Revoke_Call

+ func (_c *MockLease_Revoke_Call) RunAndReturn(...) *MockLease_Revoke_Call

+ type MockLease_TimeToLive_Call struct

+ func (_c *MockLease_TimeToLive_Call) Return(_a0 *clientv3.LeaseTimeToLiveResponse, _a1 error) *MockLease_TimeToLive_Call

+ func (_c *MockLease_TimeToLive_Call) Run(...) *MockLease_TimeToLive_Call

+ func (_c *MockLease_TimeToLive_Call) RunAndReturn(...) *MockLease_TimeToLive_Call

+ type MockWatcher struct

+ func NewMockWatcher(t interface{ ... }) *MockWatcher

+ func (_m *MockWatcher) Close() error

+ func (_m *MockWatcher) EXPECT() *MockWatcher_Expecter

+ func (_m *MockWatcher) RequestProgress(ctx context.Context) error

+ func (_m *MockWatcher) Watch(ctx context.Context, key string, opts ...clientv3.OpOption) clientv3.WatchChan

+ type MockWatcher_Close_Call struct

+ func (_c *MockWatcher_Close_Call) Return(_a0 error) *MockWatcher_Close_Call

+ func (_c *MockWatcher_Close_Call) Run(run func()) *MockWatcher_Close_Call

+ func (_c *MockWatcher_Close_Call) RunAndReturn(run func() error) *MockWatcher_Close_Call

+ type MockWatcher_Expecter struct

+ func (_e *MockWatcher_Expecter) Close() *MockWatcher_Close_Call

+ func (_e *MockWatcher_Expecter) RequestProgress(ctx interface{}) *MockWatcher_RequestProgress_Call

+ func (_e *MockWatcher_Expecter) Watch(ctx interface{}, key interface{}, opts ...interface{}) *MockWatcher_Watch_Call

+ type MockWatcher_RequestProgress_Call struct

+ func (_c *MockWatcher_RequestProgress_Call) Return(_a0 error) *MockWatcher_RequestProgress_Call

+ func (_c *MockWatcher_RequestProgress_Call) Run(run func(ctx context.Context)) *MockWatcher_RequestProgress_Call

+ func (_c *MockWatcher_RequestProgress_Call) RunAndReturn(run func(context.Context) error) *MockWatcher_RequestProgress_Call

+ type MockWatcher_Watch_Call struct

+ func (_c *MockWatcher_Watch_Call) Return(_a0 clientv3.WatchChan) *MockWatcher_Watch_Call

+ func (_c *MockWatcher_Watch_Call) Run(run func(ctx context.Context, key string, opts ...clientv3.OpOption)) *MockWatcher_Watch_Call

+ func (_c *MockWatcher_Watch_Call) RunAndReturn(run func(context.Context, string, ...clientv3.OpOption) clientv3.WatchChan) *MockWatcher_Watch_Call

v0.0.3

Oct 17, 2024

v0.0.2

Oct 14, 2024

v0.0.1

Oct 14, 2024

Changes in this version

+ type BackendConfig struct

+ Allow []string

+ FieldsMap map[string]string

+ RequestTemplate string

+ ResponseBody string

+ type CallConfig struct

+ Backend []BackendConfig

+ Method string

+ Params validator.Config

+ type CallsConfig struct

+ Calls []CallConfig

+ type CallsRepository struct

+ func NewCallsRepository(cfg *CallsConfig) (*CallsRepository, error)

+ func (r *CallsRepository) GetCall(method string) core.Handler

+ type ConnectionRegistry struct

+ func NewConnectionRegistry() *ConnectionRegistry

+ func (c *ConnectionRegistry) GetConnection(clientConn wasabi.Connection) *core.Conn

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL