datanode

package
v0.10.3-0...-f06509b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2024 License: Apache-2.0 Imports: 69 Imported by: 0

README

Data Node

DataNode is the component to write insert and delete messages into persistent blob storage, for example MinIO or S3.

Dependency

  • KV store: a kv store that persists messages into blob storage.
  • Message stream: receive messages and publish imformation
  • Root Coordinator: get the latest unique IDs.
  • Data Coordinator: get the flush information and which message stream to subscribe.

Documentation

Overview

Package datanode implements data persistence logic.

Data node persists insert logs into persistent storage like minIO/S3.

Package datanode implements data persistence logic.

Data node persists insert logs into persistent storage like minIO/S3.

Index

Constants

View Source 
const (
	// ConnectEtcdMaxRetryTime is used to limit the max retry time for connection etcd
	ConnectEtcdMaxRetryTime = 100
)

Variables

View Source 
var Params *paramtable.ComponentParam = paramtable.Get()

Params from config.yaml

Functions

func GetLiteChannelWatchInfo 

func GetLiteChannelWatchInfo(watchInfo *datapb.ChannelWatchInfo) *datapb.ChannelWatchInfo

GetLiteChannelWatchInfo clones watchInfo without segmentIDs to reduce the size of the message

func NewOpRunner 

func NewOpRunner(channel string, dn *DataNode, f releaseFunc, resultCh chan *opState) *opRunner

Types

type BaseMsg 

type BaseMsg = flowgraph.BaseMsg

type BaseNode 

type BaseNode = flowgraph.BaseNode

BaseNode is flowgraph.BaseNode

type Blob 

type Blob = storage.Blob

Blob of storage

type Cache 

type Cache struct {
	*typeutil.ConcurrentSet[UniqueID]
}

Cache stores flushing segments' ids to prevent flushing the same segment again and again. 

Once a segment is flushed, its id will be removed from the cache.

A segment not in cache will be added into the cache when `FlushSegments` is called.
 After the flush procedure, whether the segment successfully flushed or not,
 it'll be removed from the cache. So if flush failed, the secondary flush can be triggered.

func (*Cache) Cache 

func (c *Cache) Cache(ID UniqueID)

Cache caches a specific ID into the cache

func (*Cache) Remove 

func (c *Cache) Remove(IDs ...UniqueID)

Remove removes a set of IDs from the cache

type ChannelManager 

type ChannelManager interface {
	Submit(info *datapb.ChannelWatchInfo) error
	GetProgress(info *datapb.ChannelWatchInfo) *datapb.ChannelOperationProgressResponse
	Close()
	Start()
}

type ChannelManagerImpl 

type ChannelManagerImpl struct {
	// contains filtered or unexported fields
}

func NewChannelManager 

func NewChannelManager(dn *DataNode) *ChannelManagerImpl

func (*ChannelManagerImpl) Close 

func (m *ChannelManagerImpl) Close()

func (*ChannelManagerImpl) GetProgress 

func (m *ChannelManagerImpl) GetProgress(info *datapb.ChannelWatchInfo) *datapb.ChannelOperationProgressResponse

func (*ChannelManagerImpl) Start 

func (m *ChannelManagerImpl) Start()

func (*ChannelManagerImpl) Submit 

func (m *ChannelManagerImpl) Submit(info *datapb.ChannelWatchInfo) error

type DSL 

type DSL = string

DSL is type string

type DataNode 

type DataNode struct {
	Role string
	// contains filtered or unexported fields
}

DataNode communicates with outside services and unioun all services in datanode package.

DataNode implements `types.Component`, `types.DataNode` interfaces. 

`etcdCli`   is a connection of etcd
`rootCoord` is a grpc client of root coordinator.
`dataCoord` is a grpc client of data service.
`stateCode` is current statement of this data node, indicating whether it's healthy.

`clearSignal` is a signal channel for releasing the flowgraph resources.
`segmentCache` stores all flushing and flushed segments.

func NewDataNode 

func NewDataNode(ctx context.Context, factory dependency.Factory, serverID int64) *DataNode

NewDataNode will return a DataNode with abnormal state.

func (*DataNode) BackGroundGC 

func (node *DataNode) BackGroundGC(vChannelCh <-chan string)

BackGroundGC runs in background to release datanode resources GOOSE TODO: remove background GC, using ToRelease for drop-collection after #15846

func (*DataNode) CheckChannelOperationProgress 

func (node *DataNode) CheckChannelOperationProgress(ctx context.Context, req *datapb.ChannelWatchInfo) (*datapb.ChannelOperationProgressResponse, error)

func (*DataNode) Compaction 

func (node *DataNode) Compaction(ctx context.Context, req *datapb.CompactionPlan) (*commonpb.Status, error)

Compaction handles compaction request from DataCoord returns status as long as compaction task enqueued or invalid

func (*DataNode) DropImport 

func (node *DataNode) DropImport(ctx context.Context, req *datapb.DropImportRequest) (*commonpb.Status, error)

func (*DataNode) FlushChannels 

func (node *DataNode) FlushChannels(ctx context.Context, req *datapb.FlushChannelsRequest) (*commonpb.Status, error)

func (*DataNode) FlushSegments 

func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmentsRequest) (*commonpb.Status, error)

func (*DataNode) GetAddress 

func (node *DataNode) GetAddress() string

func (*DataNode) GetCompactionState 

func (node *DataNode) GetCompactionState(ctx context.Context, req *datapb.CompactionStateRequest) (*datapb.CompactionStateResponse, error)

GetCompactionState called by DataCoord return status of all compaction plans

func (*DataNode) GetComponentStates 

func (node *DataNode) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)

GetComponentStates will return current state of DataNode

func (*DataNode) GetMetrics 

func (node *DataNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)

GetMetrics return datanode metrics

func (*DataNode) GetNodeID 

func (node *DataNode) GetNodeID() int64

func (*DataNode) GetSession 

func (node *DataNode) GetSession() *sessionutil.Session

to fix data race

func (*DataNode) GetStateCode 

func (node *DataNode) GetStateCode() commonpb.StateCode

GetStateCode return datanode's state code

func (*DataNode) GetStatisticsChannel 

func (node *DataNode) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)

GetStatisticsChannel currently do nothing

func (*DataNode) GetTimeTickChannel 

func (node *DataNode) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)

GetTimeTickChannel currently do nothing

func (*DataNode) ImportV2 

func (node *DataNode) ImportV2(ctx context.Context, req *datapb.ImportRequest) (*commonpb.Status, error)

func (*DataNode) Init 

func (node *DataNode) Init() error

func (*DataNode) NotifyChannelOperation 

func (node *DataNode) NotifyChannelOperation(ctx context.Context, req *datapb.ChannelOperationsRequest) (*commonpb.Status, error)

func (*DataNode) PreImport 

func (node *DataNode) PreImport(ctx context.Context, req *datapb.PreImportRequest) (*commonpb.Status, error)

func (*DataNode) QueryImport 

func (node *DataNode) QueryImport(ctx context.Context, req *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error)

func (*DataNode) QueryPreImport 

func (node *DataNode) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error)

func (*DataNode) ReadyToFlush 

func (node *DataNode) ReadyToFlush() error

ReadyToFlush tells whether DataNode is ready for flushing

func (*DataNode) Register 

func (node *DataNode) Register() error

Register register datanode to etcd

func (*DataNode) ResendSegmentStats 

func (node *DataNode) ResendSegmentStats(ctx context.Context, req *datapb.ResendSegmentStatsRequest) (*datapb.ResendSegmentStatsResponse, error)

ResendSegmentStats . ResendSegmentStats resend un-flushed segment stats back upstream to DataCoord by resending DataNode time tick message. It returns a list of segments to be sent. Deprecated in 2.3.2, reversed it just for compatibility during rolling back

func (*DataNode) SetAddress 

func (node *DataNode) SetAddress(address string)

func (*DataNode) SetDataCoordClient 

func (node *DataNode) SetDataCoordClient(ds types.DataCoordClient) error

SetDataCoordClient sets data service's grpc client, error is returned if repeatedly set.

func (*DataNode) SetEtcdClient 

func (node *DataNode) SetEtcdClient(etcdCli *clientv3.Client)

SetEtcdClient sets etcd client for DataNode

func (*DataNode) SetRootCoordClient 

func (node *DataNode) SetRootCoordClient(rc types.RootCoordClient) error

SetRootCoordClient sets RootCoord's grpc client, error is returned if repeatedly set.

func (*DataNode) SetSession 

func (node *DataNode) SetSession(session *sessionutil.Session)

to fix data race

func (*DataNode) ShowConfigurations 

func (node *DataNode) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)

ShowConfigurations returns the configurations of DataNode matching req.Pattern

func (*DataNode) Start 

func (node *DataNode) Start() error

Start will update DataNode state to HEALTHY

func (*DataNode) StartWatchChannels 

func (node *DataNode) StartWatchChannels(ctx context.Context)

StartWatchChannels start loop to watch channel allocation status via kv(etcd for now)

func (*DataNode) Stop 

func (node *DataNode) Stop() error

Stop will release DataNode resources and shutdown datanode

func (*DataNode) SyncSegments 

func (node *DataNode) SyncSegments(ctx context.Context, req *datapb.SyncSegmentsRequest) (*commonpb.Status, error)

SyncSegments called by DataCoord, sync the compacted segments' meta between DC and DN

func (*DataNode) UpdateStateCode 

func (node *DataNode) UpdateStateCode(code commonpb.StateCode)

UpdateStateCode updates datanode's state code

func (*DataNode) WatchDmChannels 

func (node *DataNode) WatchDmChannels(ctx context.Context, in *datapb.WatchDmChannelsRequest) (*commonpb.Status, error)

WatchDmChannels is not in use

type DeleteData 

type DeleteData = storage.DeleteData

DeleteData record deleted IDs and Timestamps

type EventManager 

type EventManager struct {
	// contains filtered or unexported fields
}

func NewEventManager 

func NewEventManager() *EventManager

func (*EventManager) CloseAll 

func (m *EventManager) CloseAll()

func (*EventManager) GetOrInsert 

func (m *EventManager) GetOrInsert(channel string, newManager *channelEventManager) *channelEventManager

func (*EventManager) Remove 

func (m *EventManager) Remove(channel string)

type FlowgraphManager 

type FlowgraphManager interface {
	AddFlowgraph(ds *dataSyncService)
	AddandStartWithEtcdTickler(dn *DataNode, vchan *datapb.VchannelInfo, schema *schemapb.CollectionSchema, tickler *etcdTickler) error
	RemoveFlowgraph(channel string)
	ClearFlowgraphs()

	GetFlowgraphService(channel string) (*dataSyncService, bool)
	HasFlowgraph(channel string) bool
	HasFlowgraphWithOpID(channel string, opID UniqueID) bool
	GetFlowgraphCount() int
	GetCollectionIDs() []int64

	Close()
}

type InputNode 

type InputNode = flowgraph.InputNode

InputNode is flowgraph.InputNode

type InsertData 

type InsertData = storage.InsertData

InsertData of storage

type IntPrimaryKey 

type IntPrimaryKey = typeutil.IntPrimaryKey

IntPrimaryKey is type int64

type MockChannelManager 

type MockChannelManager struct {
	mock.Mock
}

MockChannelManager is an autogenerated mock type for the ChannelManager type

func NewMockChannelManager 

func NewMockChannelManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockChannelManager

NewMockChannelManager creates a new instance of MockChannelManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockChannelManager) Close 

func (_m *MockChannelManager) Close()

Close provides a mock function with given fields:

func (*MockChannelManager) EXPECT 

func (_m *MockChannelManager) EXPECT() *MockChannelManager_Expecter

func (*MockChannelManager) GetProgress 

func (_m *MockChannelManager) GetProgress(info *datapb.ChannelWatchInfo) *datapb.ChannelOperationProgressResponse

GetProgress provides a mock function with given fields: info

func (*MockChannelManager) Start 

func (_m *MockChannelManager) Start()

Start provides a mock function with given fields:

func (*MockChannelManager) Submit 

func (_m *MockChannelManager) Submit(info *datapb.ChannelWatchInfo) error

Submit provides a mock function with given fields: info

type MockChannelManager_Close_Call 

type MockChannelManager_Close_Call struct {
	*mock.Call
}

MockChannelManager_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'

func (*MockChannelManager_Close_Call) Return 

func (_c *MockChannelManager_Close_Call) Return() *MockChannelManager_Close_Call

func (*MockChannelManager_Close_Call) Run 

func (_c *MockChannelManager_Close_Call) Run(run func()) *MockChannelManager_Close_Call

func (*MockChannelManager_Close_Call) RunAndReturn 

func (_c *MockChannelManager_Close_Call) RunAndReturn(run func()) *MockChannelManager_Close_Call

type MockChannelManager_Expecter 

type MockChannelManager_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockChannelManager_Expecter) Close 

func (_e *MockChannelManager_Expecter) Close() *MockChannelManager_Close_Call

Close is a helper method to define mock.On call

func (*MockChannelManager_Expecter) GetProgress 

func (_e *MockChannelManager_Expecter) GetProgress(info interface{}) *MockChannelManager_GetProgress_Call

GetProgress is a helper method to define mock.On call

  • info *datapb.ChannelWatchInfo

func (*MockChannelManager_Expecter) Start 

func (_e *MockChannelManager_Expecter) Start() *MockChannelManager_Start_Call

Start is a helper method to define mock.On call

func (*MockChannelManager_Expecter) Submit 

func (_e *MockChannelManager_Expecter) Submit(info interface{}) *MockChannelManager_Submit_Call

Submit is a helper method to define mock.On call

  • info *datapb.ChannelWatchInfo

type MockChannelManager_GetProgress_Call 

type MockChannelManager_GetProgress_Call struct {
	*mock.Call
}

MockChannelManager_GetProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProgress'

func (*MockChannelManager_GetProgress_Call) Return 

func (_c *MockChannelManager_GetProgress_Call) Return(_a0 *datapb.ChannelOperationProgressResponse) *MockChannelManager_GetProgress_Call

func (*MockChannelManager_GetProgress_Call) Run 

func (_c *MockChannelManager_GetProgress_Call) Run(run func(info *datapb.ChannelWatchInfo)) *MockChannelManager_GetProgress_Call

func (*MockChannelManager_GetProgress_Call) RunAndReturn 

func (_c *MockChannelManager_GetProgress_Call) RunAndReturn(run func(*datapb.ChannelWatchInfo) *datapb.ChannelOperationProgressResponse) *MockChannelManager_GetProgress_Call

type MockChannelManager_Start_Call 

type MockChannelManager_Start_Call struct {
	*mock.Call
}

MockChannelManager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'

func (*MockChannelManager_Start_Call) Return 

func (_c *MockChannelManager_Start_Call) Return() *MockChannelManager_Start_Call

func (*MockChannelManager_Start_Call) Run 

func (_c *MockChannelManager_Start_Call) Run(run func()) *MockChannelManager_Start_Call

func (*MockChannelManager_Start_Call) RunAndReturn 

func (_c *MockChannelManager_Start_Call) RunAndReturn(run func()) *MockChannelManager_Start_Call

type MockChannelManager_Submit_Call 

type MockChannelManager_Submit_Call struct {
	*mock.Call
}

MockChannelManager_Submit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Submit'

func (*MockChannelManager_Submit_Call) Return 

func (_c *MockChannelManager_Submit_Call) Return(_a0 error) *MockChannelManager_Submit_Call

func (*MockChannelManager_Submit_Call) Run 

func (_c *MockChannelManager_Submit_Call) Run(run func(info *datapb.ChannelWatchInfo)) *MockChannelManager_Submit_Call

func (*MockChannelManager_Submit_Call) RunAndReturn 

func (_c *MockChannelManager_Submit_Call) RunAndReturn(run func(*datapb.ChannelWatchInfo) error) *MockChannelManager_Submit_Call

type MockFlowgraphManager 

type MockFlowgraphManager struct {
	mock.Mock
}

MockFlowgraphManager is an autogenerated mock type for the FlowgraphManager type

func NewMockFlowgraphManager 

func NewMockFlowgraphManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFlowgraphManager

NewMockFlowgraphManager creates a new instance of MockFlowgraphManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockFlowgraphManager) AddFlowgraph 

func (_m *MockFlowgraphManager) AddFlowgraph(ds *dataSyncService)

AddFlowgraph provides a mock function with given fields: ds

func (*MockFlowgraphManager) AddandStartWithEtcdTickler 

func (_m *MockFlowgraphManager) AddandStartWithEtcdTickler(dn *DataNode, vchan *datapb.VchannelInfo, schema *schemapb.CollectionSchema, tickler *etcdTickler) error

AddandStartWithEtcdTickler provides a mock function with given fields: dn, vchan, schema, tickler

func (*MockFlowgraphManager) ClearFlowgraphs 

func (_m *MockFlowgraphManager) ClearFlowgraphs()

ClearFlowgraphs provides a mock function with given fields:

func (*MockFlowgraphManager) EXPECT 

func (_m *MockFlowgraphManager) EXPECT() *MockFlowgraphManager_Expecter

func (*MockFlowgraphManager) GetCollectionIDs 

func (_m *MockFlowgraphManager) GetCollectionIDs() []int64

GetCollectionIDs provides a mock function with given fields:

func (*MockFlowgraphManager) GetFlowgraphCount 

func (_m *MockFlowgraphManager) GetFlowgraphCount() int

GetFlowgraphCount provides a mock function with given fields:

func (*MockFlowgraphManager) GetFlowgraphService 

func (_m *MockFlowgraphManager) GetFlowgraphService(channel string) (*dataSyncService, bool)

GetFlowgraphService provides a mock function with given fields: channel

func (*MockFlowgraphManager) HasFlowgraph 

func (_m *MockFlowgraphManager) HasFlowgraph(channel string) bool

HasFlowgraph provides a mock function with given fields: channel

func (*MockFlowgraphManager) HasFlowgraphWithOpID 

func (_m *MockFlowgraphManager) HasFlowgraphWithOpID(channel string, opID int64) bool

HasFlowgraphWithOpID provides a mock function with given fields: channel, opID

func (*MockFlowgraphManager) RemoveFlowgraph 

func (_m *MockFlowgraphManager) RemoveFlowgraph(channel string)

RemoveFlowgraph provides a mock function with given fields: channel

type MockFlowgraphManager_AddFlowgraph_Call 

type MockFlowgraphManager_AddFlowgraph_Call struct {
	*mock.Call
}

MockFlowgraphManager_AddFlowgraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFlowgraph'

func (*MockFlowgraphManager_AddFlowgraph_Call) Return 

func (_c *MockFlowgraphManager_AddFlowgraph_Call) Return() *MockFlowgraphManager_AddFlowgraph_Call

func (*MockFlowgraphManager_AddFlowgraph_Call) Run 

func (_c *MockFlowgraphManager_AddFlowgraph_Call) Run(run func(ds *dataSyncService)) *MockFlowgraphManager_AddFlowgraph_Call

func (*MockFlowgraphManager_AddFlowgraph_Call) RunAndReturn 

func (_c *MockFlowgraphManager_AddFlowgraph_Call) RunAndReturn(run func(*dataSyncService)) *MockFlowgraphManager_AddFlowgraph_Call

type MockFlowgraphManager_AddandStartWithEtcdTickler_Call 

type MockFlowgraphManager_AddandStartWithEtcdTickler_Call struct {
	*mock.Call
}

MockFlowgraphManager_AddandStartWithEtcdTickler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddandStartWithEtcdTickler'

func (*MockFlowgraphManager_AddandStartWithEtcdTickler_Call) Return 

func (_c *MockFlowgraphManager_AddandStartWithEtcdTickler_Call) Return(_a0 error) *MockFlowgraphManager_AddandStartWithEtcdTickler_Call

func (*MockFlowgraphManager_AddandStartWithEtcdTickler_Call) Run 

func (_c *MockFlowgraphManager_AddandStartWithEtcdTickler_Call) Run(run func(dn *DataNode, vchan *datapb.VchannelInfo, schema *schemapb.CollectionSchema, tickler *etcdTickler)) *MockFlowgraphManager_AddandStartWithEtcdTickler_Call

func (*MockFlowgraphManager_AddandStartWithEtcdTickler_Call) RunAndReturn 

func (_c *MockFlowgraphManager_AddandStartWithEtcdTickler_Call) RunAndReturn(run func(*DataNode, *datapb.VchannelInfo, *schemapb.CollectionSchema, *etcdTickler) error) *MockFlowgraphManager_AddandStartWithEtcdTickler_Call

type MockFlowgraphManager_ClearFlowgraphs_Call 

type MockFlowgraphManager_ClearFlowgraphs_Call struct {
	*mock.Call
}

MockFlowgraphManager_ClearFlowgraphs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearFlowgraphs'

func (*MockFlowgraphManager_ClearFlowgraphs_Call) Return 

func (_c *MockFlowgraphManager_ClearFlowgraphs_Call) Return() *MockFlowgraphManager_ClearFlowgraphs_Call

func (*MockFlowgraphManager_ClearFlowgraphs_Call) Run 

func (_c *MockFlowgraphManager_ClearFlowgraphs_Call) Run(run func()) *MockFlowgraphManager_ClearFlowgraphs_Call

func (*MockFlowgraphManager_ClearFlowgraphs_Call) RunAndReturn 

func (_c *MockFlowgraphManager_ClearFlowgraphs_Call) RunAndReturn(run func()) *MockFlowgraphManager_ClearFlowgraphs_Call

type MockFlowgraphManager_Expecter 

type MockFlowgraphManager_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFlowgraphManager_Expecter) AddFlowgraph 

func (_e *MockFlowgraphManager_Expecter) AddFlowgraph(ds interface{}) *MockFlowgraphManager_AddFlowgraph_Call

AddFlowgraph is a helper method to define mock.On call

  • ds *dataSyncService

func (*MockFlowgraphManager_Expecter) AddandStartWithEtcdTickler 

func (_e *MockFlowgraphManager_Expecter) AddandStartWithEtcdTickler(dn interface{}, vchan interface{}, schema interface{}, tickler interface{}) *MockFlowgraphManager_AddandStartWithEtcdTickler_Call

AddandStartWithEtcdTickler is a helper method to define mock.On call

  • dn *DataNode
  • vchan *datapb.VchannelInfo
  • schema *schemapb.CollectionSchema
  • tickler *etcdTickler

func (*MockFlowgraphManager_Expecter) ClearFlowgraphs 

func (_e *MockFlowgraphManager_Expecter) ClearFlowgraphs() *MockFlowgraphManager_ClearFlowgraphs_Call

ClearFlowgraphs is a helper method to define mock.On call

func (*MockFlowgraphManager_Expecter) GetCollectionIDs 

func (_e *MockFlowgraphManager_Expecter) GetCollectionIDs() *MockFlowgraphManager_GetCollectionIDs_Call

GetCollectionIDs is a helper method to define mock.On call

func (*MockFlowgraphManager_Expecter) GetFlowgraphCount 

func (_e *MockFlowgraphManager_Expecter) GetFlowgraphCount() *MockFlowgraphManager_GetFlowgraphCount_Call

GetFlowgraphCount is a helper method to define mock.On call

func (*MockFlowgraphManager_Expecter) GetFlowgraphService 

func (_e *MockFlowgraphManager_Expecter) GetFlowgraphService(channel interface{}) *MockFlowgraphManager_GetFlowgraphService_Call

GetFlowgraphService is a helper method to define mock.On call

  • channel string

func (*MockFlowgraphManager_Expecter) HasFlowgraph 

func (_e *MockFlowgraphManager_Expecter) HasFlowgraph(channel interface{}) *MockFlowgraphManager_HasFlowgraph_Call

HasFlowgraph is a helper method to define mock.On call

  • channel string

func (*MockFlowgraphManager_Expecter) HasFlowgraphWithOpID 

func (_e *MockFlowgraphManager_Expecter) HasFlowgraphWithOpID(channel interface{}, opID interface{}) *MockFlowgraphManager_HasFlowgraphWithOpID_Call

HasFlowgraphWithOpID is a helper method to define mock.On call

  • channel string
  • opID int64

func (*MockFlowgraphManager_Expecter) RemoveFlowgraph 

func (_e *MockFlowgraphManager_Expecter) RemoveFlowgraph(channel interface{}) *MockFlowgraphManager_RemoveFlowgraph_Call

RemoveFlowgraph is a helper method to define mock.On call

  • channel string

type MockFlowgraphManager_GetCollectionIDs_Call 

type MockFlowgraphManager_GetCollectionIDs_Call struct {
	*mock.Call
}

MockFlowgraphManager_GetCollectionIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCollectionIDs'

func (*MockFlowgraphManager_GetCollectionIDs_Call) Return 

func (_c *MockFlowgraphManager_GetCollectionIDs_Call) Return(_a0 []int64) *MockFlowgraphManager_GetCollectionIDs_Call

func (*MockFlowgraphManager_GetCollectionIDs_Call) Run 

func (_c *MockFlowgraphManager_GetCollectionIDs_Call) Run(run func()) *MockFlowgraphManager_GetCollectionIDs_Call

func (*MockFlowgraphManager_GetCollectionIDs_Call) RunAndReturn 

func (_c *MockFlowgraphManager_GetCollectionIDs_Call) RunAndReturn(run func() []int64) *MockFlowgraphManager_GetCollectionIDs_Call

type MockFlowgraphManager_GetFlowgraphCount_Call 

type MockFlowgraphManager_GetFlowgraphCount_Call struct {
	*mock.Call
}

MockFlowgraphManager_GetFlowgraphCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlowgraphCount'

func (*MockFlowgraphManager_GetFlowgraphCount_Call) Return 

func (_c *MockFlowgraphManager_GetFlowgraphCount_Call) Return(_a0 int) *MockFlowgraphManager_GetFlowgraphCount_Call

func (*MockFlowgraphManager_GetFlowgraphCount_Call) Run 

func (_c *MockFlowgraphManager_GetFlowgraphCount_Call) Run(run func()) *MockFlowgraphManager_GetFlowgraphCount_Call

func (*MockFlowgraphManager_GetFlowgraphCount_Call) RunAndReturn 

func (_c *MockFlowgraphManager_GetFlowgraphCount_Call) RunAndReturn(run func() int) *MockFlowgraphManager_GetFlowgraphCount_Call

type MockFlowgraphManager_GetFlowgraphService_Call 

type MockFlowgraphManager_GetFlowgraphService_Call struct {
	*mock.Call
}

MockFlowgraphManager_GetFlowgraphService_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlowgraphService'

func (*MockFlowgraphManager_GetFlowgraphService_Call) Return 

func (_c *MockFlowgraphManager_GetFlowgraphService_Call) Return(_a0 *dataSyncService, _a1 bool) *MockFlowgraphManager_GetFlowgraphService_Call

func (*MockFlowgraphManager_GetFlowgraphService_Call) Run 

func (_c *MockFlowgraphManager_GetFlowgraphService_Call) Run(run func(channel string)) *MockFlowgraphManager_GetFlowgraphService_Call

func (*MockFlowgraphManager_GetFlowgraphService_Call) RunAndReturn 

func (_c *MockFlowgraphManager_GetFlowgraphService_Call) RunAndReturn(run func(string) (*dataSyncService, bool)) *MockFlowgraphManager_GetFlowgraphService_Call

type MockFlowgraphManager_HasFlowgraphWithOpID_Call 

type MockFlowgraphManager_HasFlowgraphWithOpID_Call struct {
	*mock.Call
}

MockFlowgraphManager_HasFlowgraphWithOpID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFlowgraphWithOpID'

func (*MockFlowgraphManager_HasFlowgraphWithOpID_Call) Return 

func (_c *MockFlowgraphManager_HasFlowgraphWithOpID_Call) Return(_a0 bool) *MockFlowgraphManager_HasFlowgraphWithOpID_Call

func (*MockFlowgraphManager_HasFlowgraphWithOpID_Call) Run 

func (_c *MockFlowgraphManager_HasFlowgraphWithOpID_Call) Run(run func(channel string, opID int64)) *MockFlowgraphManager_HasFlowgraphWithOpID_Call

func (*MockFlowgraphManager_HasFlowgraphWithOpID_Call) RunAndReturn 

func (_c *MockFlowgraphManager_HasFlowgraphWithOpID_Call) RunAndReturn(run func(string, int64) bool) *MockFlowgraphManager_HasFlowgraphWithOpID_Call

type MockFlowgraphManager_HasFlowgraph_Call 

type MockFlowgraphManager_HasFlowgraph_Call struct {
	*mock.Call
}

MockFlowgraphManager_HasFlowgraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFlowgraph'

func (*MockFlowgraphManager_HasFlowgraph_Call) Return 

func (_c *MockFlowgraphManager_HasFlowgraph_Call) Return(_a0 bool) *MockFlowgraphManager_HasFlowgraph_Call

func (*MockFlowgraphManager_HasFlowgraph_Call) Run 

func (_c *MockFlowgraphManager_HasFlowgraph_Call) Run(run func(channel string)) *MockFlowgraphManager_HasFlowgraph_Call

func (*MockFlowgraphManager_HasFlowgraph_Call) RunAndReturn 

func (_c *MockFlowgraphManager_HasFlowgraph_Call) RunAndReturn(run func(string) bool) *MockFlowgraphManager_HasFlowgraph_Call

type MockFlowgraphManager_RemoveFlowgraph_Call 

type MockFlowgraphManager_RemoveFlowgraph_Call struct {
	*mock.Call
}

MockFlowgraphManager_RemoveFlowgraph_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveFlowgraph'

func (*MockFlowgraphManager_RemoveFlowgraph_Call) Return 

func (_c *MockFlowgraphManager_RemoveFlowgraph_Call) Return() *MockFlowgraphManager_RemoveFlowgraph_Call

func (*MockFlowgraphManager_RemoveFlowgraph_Call) Run 

func (_c *MockFlowgraphManager_RemoveFlowgraph_Call) Run(run func(channel string)) *MockFlowgraphManager_RemoveFlowgraph_Call

func (*MockFlowgraphManager_RemoveFlowgraph_Call) RunAndReturn 

func (_c *MockFlowgraphManager_RemoveFlowgraph_Call) RunAndReturn(run func(string)) *MockFlowgraphManager_RemoveFlowgraph_Call

type Msg 

type Msg = flowgraph.Msg

Msg is flowgraph.Msg

type MsgStreamMsg 

type MsgStreamMsg = flowgraph.MsgStreamMsg

MsgStreamMsg is flowgraph.MsgStreamMsg

type Node 

type Node = flowgraph.Node

Node is flowgraph.Node

type TimeRange 

type TimeRange struct {
	// contains filtered or unexported fields
}

TimeRange is a range of timestamp contains the min-timestamp and max-timestamp

type Timestamp 

type Timestamp = typeutil.Timestamp

Timestamp is type uint64

type UniqueID 

type UniqueID = typeutil.UniqueID

UniqueID is type int64

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.