mirror of https://github.com/milvus-io/milvus.git
enhance: Remove not inused allocator (#43821)
See also: #44039 --------- Signed-off-by: yangxuan <xuan.yang@zilliz.com>pull/44085/head
XuanYang-cn
GitHub
parent
d3fa305785
commit
09b29a88aa
|
|
@ -111,3 +111,6 @@ internal/core/src/pb/*.pb.h
|
|||
internal/core/src/pb/*.pb.cc
|
||||
**/legacypb/*.pb.go
|
||||
pkg/streaming/proto/**/*.pb.go
|
||||
|
||||
#AI rules
|
||||
WARP.md
|
||||
|
|
|
|||
|
|
@ -6,13 +6,7 @@ mockname: "Mock{{.InterfaceName}}"
|
|||
outpkg: "{{.PackageName}}"
|
||||
dir: "{{.InterfaceDir}}"
|
||||
packages:
|
||||
github.com/milvus-io/milvus/internal/datanode/allocator:
|
||||
interfaces:
|
||||
Allocator:
|
||||
github.com/milvus-io/milvus/internal/datanode/channel:
|
||||
interfaces:
|
||||
ChannelManager:
|
||||
github.com/milvus-io/milvus/internal/datanode/compaction:
|
||||
github.com/milvus-io/milvus/internal/datanode/compactor:
|
||||
interfaces:
|
||||
Compactor:
|
||||
github.com/milvus-io/milvus/internal/datanode/importv2:
|
||||
|
|
|
|||
|
|
@ -1,80 +0,0 @@
|
|||
// Licensed to the LF AI & Data foundation under one
|
||||
// or more contributor license agreements. See the NOTICE file
|
||||
// distributed with this work for additional information
|
||||
// regarding copyright ownership. The ASF licenses this file
|
||||
// to you under the Apache License, Version 2.0 (the
|
||||
// "License"); you may not use this file except in compliance
|
||||
// with the License. You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 allocator
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
gAllocator "github.com/milvus-io/milvus/internal/allocator"
|
||||
"github.com/milvus-io/milvus/internal/types"
|
||||
"github.com/milvus-io/milvus/pkg/v2/util/typeutil"
|
||||
)
|
||||
|
||||
type UniqueID = typeutil.UniqueID
|
||||
|
||||
type Allocator interface {
|
||||
Start() error
|
||||
Close()
|
||||
AllocOne() (UniqueID, error)
|
||||
Alloc(count uint32) (UniqueID, UniqueID, error)
|
||||
GetGenerator(count int, done <-chan struct{}) (<-chan UniqueID, error)
|
||||
GetIDAlloactor() *gAllocator.IDAllocator
|
||||
}
|
||||
|
||||
var _ Allocator = (*Impl)(nil)
|
||||
|
||||
type Impl struct {
|
||||
// Start() error
|
||||
// Close() error
|
||||
// AllocOne() (UniqueID, error)
|
||||
// Alloc(count uint32) (UniqueID, UniqueID, error)
|
||||
*gAllocator.IDAllocator
|
||||
}
|
||||
|
||||
func New(ctx context.Context, rootCoord types.RootCoordClient, peerID UniqueID) (Allocator, error) {
|
||||
idAlloc, err := gAllocator.NewIDAllocator(ctx, rootCoord, peerID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Impl{idAlloc}, nil
|
||||
}
|
||||
|
||||
func (a *Impl) GetIDAlloactor() *gAllocator.IDAllocator {
|
||||
return a.IDAllocator
|
||||
}
|
||||
|
||||
func (a *Impl) GetGenerator(count int, done <-chan struct{}) (<-chan UniqueID, error) {
|
||||
idStart, _, err := a.Alloc(uint32(count))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
rt := make(chan UniqueID)
|
||||
go func(rt chan<- UniqueID) {
|
||||
for i := 0; i < count; i++ {
|
||||
select {
|
||||
case <-done:
|
||||
close(rt)
|
||||
return
|
||||
case rt <- idStart + UniqueID(i):
|
||||
}
|
||||
}
|
||||
close(rt)
|
||||
}(rt)
|
||||
|
||||
return rt, nil
|
||||
}
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
// Licensed to the LF AI & Data foundation under one
|
||||
// or more contributor license agreements. See the NOTICE file
|
||||
// distributed with this work for additional information
|
||||
// regarding copyright ownership. The ASF licenses this file
|
||||
// to you under the Apache License, Version 2.0 (the
|
||||
// "License"); you may not use this file except in compliance
|
||||
// with the License. You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// 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 allocator
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"google.golang.org/grpc"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/types"
|
||||
"github.com/milvus-io/milvus/pkg/v2/proto/rootcoordpb"
|
||||
"github.com/milvus-io/milvus/pkg/v2/util/merr"
|
||||
)
|
||||
|
||||
func TestGetGenerator(t *testing.T) {
|
||||
tests := []struct {
|
||||
isvalid bool
|
||||
innumber int
|
||||
|
||||
expectedNo int
|
||||
description string
|
||||
}{
|
||||
{true, 1, 1, "valid input n 1"},
|
||||
{true, 3, 3, "valid input n 3 with cancel"},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
rc := &RootCoordFactory{ID: 11111}
|
||||
alloc, err := New(context.TODO(), rc, 100)
|
||||
require.NoError(t, err)
|
||||
err = alloc.Start()
|
||||
require.NoError(t, err)
|
||||
|
||||
t.Run(test.description, func(t *testing.T) {
|
||||
done := make(chan struct{})
|
||||
gen, err := alloc.GetGenerator(test.innumber, done)
|
||||
assert.NoError(t, err)
|
||||
|
||||
r := make([]UniqueID, 0)
|
||||
for i := range gen {
|
||||
r = append(r, i)
|
||||
}
|
||||
|
||||
assert.Equal(t, test.expectedNo, len(r))
|
||||
|
||||
if test.innumber > 1 {
|
||||
donedone := make(chan struct{})
|
||||
gen, err := alloc.GetGenerator(test.innumber, donedone)
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, ok := <-gen
|
||||
assert.True(t, ok)
|
||||
|
||||
donedone <- struct{}{}
|
||||
|
||||
_, ok = <-gen
|
||||
assert.False(t, ok)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type RootCoordFactory struct {
|
||||
types.RootCoordClient
|
||||
ID UniqueID
|
||||
}
|
||||
|
||||
func (m *RootCoordFactory) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest, opts ...grpc.CallOption) (*rootcoordpb.AllocIDResponse, error) {
|
||||
resp := &rootcoordpb.AllocIDResponse{
|
||||
ID: m.ID,
|
||||
Count: in.GetCount(),
|
||||
Status: merr.Success(),
|
||||
}
|
||||
return resp, nil
|
||||
}
|
||||
|
|
@ -1,336 +0,0 @@
|
|||
// Code generated by mockery v2.53.3. DO NOT EDIT.
|
||||
|
||||
package allocator
|
||||
|
||||
import (
|
||||
internalallocator "github.com/milvus-io/milvus/internal/allocator"
|
||||
mock "github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
// MockAllocator is an autogenerated mock type for the Allocator type
|
||||
type MockAllocator struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
type MockAllocator_Expecter struct {
|
||||
mock *mock.Mock
|
||||
}
|
||||
|
||||
func (_m *MockAllocator) EXPECT() *MockAllocator_Expecter {
|
||||
return &MockAllocator_Expecter{mock: &_m.Mock}
|
||||
}
|
||||
|
||||
// Alloc provides a mock function with given fields: count
|
||||
func (_m *MockAllocator) Alloc(count uint32) (int64, int64, error) {
|
||||
ret := _m.Called(count)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for Alloc")
|
||||
}
|
||||
|
||||
var r0 int64
|
||||
var r1 int64
|
||||
var r2 error
|
||||
if rf, ok := ret.Get(0).(func(uint32) (int64, int64, error)); ok {
|
||||
return rf(count)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(uint32) int64); ok {
|
||||
r0 = rf(count)
|
||||
} else {
|
||||
r0 = ret.Get(0).(int64)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(uint32) int64); ok {
|
||||
r1 = rf(count)
|
||||
} else {
|
||||
r1 = ret.Get(1).(int64)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(2).(func(uint32) error); ok {
|
||||
r2 = rf(count)
|
||||
} else {
|
||||
r2 = ret.Error(2)
|
||||
}
|
||||
|
||||
return r0, r1, r2
|
||||
}
|
||||
|
||||
// MockAllocator_Alloc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Alloc'
|
||||
type MockAllocator_Alloc_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// Alloc is a helper method to define mock.On call
|
||||
// - count uint32
|
||||
func (_e *MockAllocator_Expecter) Alloc(count interface{}) *MockAllocator_Alloc_Call {
|
||||
return &MockAllocator_Alloc_Call{Call: _e.mock.On("Alloc", count)}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Alloc_Call) Run(run func(count uint32)) *MockAllocator_Alloc_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run(args[0].(uint32))
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Alloc_Call) Return(_a0 int64, _a1 int64, _a2 error) *MockAllocator_Alloc_Call {
|
||||
_c.Call.Return(_a0, _a1, _a2)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Alloc_Call) RunAndReturn(run func(uint32) (int64, int64, error)) *MockAllocator_Alloc_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// AllocOne provides a mock function with no fields
|
||||
func (_m *MockAllocator) AllocOne() (int64, error) {
|
||||
ret := _m.Called()
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for AllocOne")
|
||||
}
|
||||
|
||||
var r0 int64
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
|
||||
return rf()
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func() int64); ok {
|
||||
r0 = rf()
|
||||
} else {
|
||||
r0 = ret.Get(0).(int64)
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func() error); ok {
|
||||
r1 = rf()
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockAllocator_AllocOne_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllocOne'
|
||||
type MockAllocator_AllocOne_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// AllocOne is a helper method to define mock.On call
|
||||
func (_e *MockAllocator_Expecter) AllocOne() *MockAllocator_AllocOne_Call {
|
||||
return &MockAllocator_AllocOne_Call{Call: _e.mock.On("AllocOne")}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_AllocOne_Call) Run(run func()) *MockAllocator_AllocOne_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run()
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_AllocOne_Call) Return(_a0 int64, _a1 error) *MockAllocator_AllocOne_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_AllocOne_Call) RunAndReturn(run func() (int64, error)) *MockAllocator_AllocOne_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// Close provides a mock function with no fields
|
||||
func (_m *MockAllocator) Close() {
|
||||
_m.Called()
|
||||
}
|
||||
|
||||
// MockAllocator_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
|
||||
type MockAllocator_Close_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// Close is a helper method to define mock.On call
|
||||
func (_e *MockAllocator_Expecter) Close() *MockAllocator_Close_Call {
|
||||
return &MockAllocator_Close_Call{Call: _e.mock.On("Close")}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Close_Call) Run(run func()) *MockAllocator_Close_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run()
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Close_Call) Return() *MockAllocator_Close_Call {
|
||||
_c.Call.Return()
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Close_Call) RunAndReturn(run func()) *MockAllocator_Close_Call {
|
||||
_c.Run(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// GetGenerator provides a mock function with given fields: count, done
|
||||
func (_m *MockAllocator) GetGenerator(count int, done <-chan struct{}) (<-chan int64, error) {
|
||||
ret := _m.Called(count, done)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for GetGenerator")
|
||||
}
|
||||
|
||||
var r0 <-chan int64
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(int, <-chan struct{}) (<-chan int64, error)); ok {
|
||||
return rf(count, done)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(int, <-chan struct{}) <-chan int64); ok {
|
||||
r0 = rf(count, done)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(<-chan int64)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(int, <-chan struct{}) error); ok {
|
||||
r1 = rf(count, done)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockAllocator_GetGenerator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGenerator'
|
||||
type MockAllocator_GetGenerator_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// GetGenerator is a helper method to define mock.On call
|
||||
// - count int
|
||||
// - done <-chan struct{}
|
||||
func (_e *MockAllocator_Expecter) GetGenerator(count interface{}, done interface{}) *MockAllocator_GetGenerator_Call {
|
||||
return &MockAllocator_GetGenerator_Call{Call: _e.mock.On("GetGenerator", count, done)}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetGenerator_Call) Run(run func(count int, done <-chan struct{})) *MockAllocator_GetGenerator_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run(args[0].(int), args[1].(<-chan struct{}))
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetGenerator_Call) Return(_a0 <-chan int64, _a1 error) *MockAllocator_GetGenerator_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetGenerator_Call) RunAndReturn(run func(int, <-chan struct{}) (<-chan int64, error)) *MockAllocator_GetGenerator_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// GetIDAlloactor provides a mock function with no fields
|
||||
func (_m *MockAllocator) GetIDAlloactor() *internalallocator.IDAllocator {
|
||||
ret := _m.Called()
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for GetIDAlloactor")
|
||||
}
|
||||
|
||||
var r0 *internalallocator.IDAllocator
|
||||
if rf, ok := ret.Get(0).(func() *internalallocator.IDAllocator); ok {
|
||||
r0 = rf()
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*internalallocator.IDAllocator)
|
||||
}
|
||||
}
|
||||
|
||||
return r0
|
||||
}
|
||||
|
||||
// MockAllocator_GetIDAlloactor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIDAlloactor'
|
||||
type MockAllocator_GetIDAlloactor_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// GetIDAlloactor is a helper method to define mock.On call
|
||||
func (_e *MockAllocator_Expecter) GetIDAlloactor() *MockAllocator_GetIDAlloactor_Call {
|
||||
return &MockAllocator_GetIDAlloactor_Call{Call: _e.mock.On("GetIDAlloactor")}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetIDAlloactor_Call) Run(run func()) *MockAllocator_GetIDAlloactor_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run()
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetIDAlloactor_Call) Return(_a0 *internalallocator.IDAllocator) *MockAllocator_GetIDAlloactor_Call {
|
||||
_c.Call.Return(_a0)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_GetIDAlloactor_Call) RunAndReturn(run func() *internalallocator.IDAllocator) *MockAllocator_GetIDAlloactor_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// Start provides a mock function with no fields
|
||||
func (_m *MockAllocator) Start() error {
|
||||
ret := _m.Called()
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for Start")
|
||||
}
|
||||
|
||||
var r0 error
|
||||
if rf, ok := ret.Get(0).(func() error); ok {
|
||||
r0 = rf()
|
||||
} else {
|
||||
r0 = ret.Error(0)
|
||||
}
|
||||
|
||||
return r0
|
||||
}
|
||||
|
||||
// MockAllocator_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
||||
type MockAllocator_Start_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// Start is a helper method to define mock.On call
|
||||
func (_e *MockAllocator_Expecter) Start() *MockAllocator_Start_Call {
|
||||
return &MockAllocator_Start_Call{Call: _e.mock.On("Start")}
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Start_Call) Run(run func()) *MockAllocator_Start_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
run()
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Start_Call) Return(_a0 error) *MockAllocator_Start_Call {
|
||||
_c.Call.Return(_a0)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockAllocator_Start_Call) RunAndReturn(run func() error) *MockAllocator_Start_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// NewMockAllocator creates a new instance of MockAllocator. 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 NewMockAllocator(t interface {
|
||||
mock.TestingT
|
||||
Cleanup(func())
|
||||
}) *MockAllocator {
|
||||
mock := &MockAllocator{}
|
||||
mock.Mock.Test(t)
|
||||
|
||||
t.Cleanup(func() { mock.AssertExpectations(t) })
|
||||
|
||||
return mock
|
||||
}
|
||||
|
|
@ -27,8 +27,8 @@ import (
|
|||
"go.uber.org/zap"
|
||||
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/allocator"
|
||||
"github.com/milvus-io/milvus/internal/compaction"
|
||||
"github.com/milvus-io/milvus/internal/datanode/allocator"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/metacache/pkoracle"
|
||||
"github.com/milvus-io/milvus/internal/mocks"
|
||||
"github.com/milvus-io/milvus/internal/mocks/flushcommon/mock_util"
|
||||
|
|
|
|||
|
|
@ -371,8 +371,7 @@ func (_c *MockCompactor_Stop_Call) RunAndReturn(run func()) *MockCompactor_Stop_
|
|||
func NewMockCompactor(t interface {
|
||||
mock.TestingT
|
||||
Cleanup(func())
|
||||
},
|
||||
) *MockCompactor {
|
||||
}) *MockCompactor {
|
||||
mock := &MockCompactor{}
|
||||
mock.Mock.Test(t)
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ import (
|
|||
"github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/msgpb"
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/datanode/allocator"
|
||||
"github.com/milvus-io/milvus/internal/allocator"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/broker"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/metacache"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/syncmgr"
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ import (
|
|||
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/datanode/allocator"
|
||||
"github.com/milvus-io/milvus/internal/allocator"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/broker"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/metacache"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/metacache/pkoracle"
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ import (
|
|||
"github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/msgpb"
|
||||
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/datanode/allocator"
|
||||
"github.com/milvus-io/milvus/internal/allocator"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/metacache"
|
||||
"github.com/milvus-io/milvus/internal/flushcommon/syncmgr"
|
||||
"github.com/milvus-io/milvus/pkg/v2/common"
|
||||
|
|
|
|||
Loading…
Reference in New Issue