dragonflyoss
/
dragonfly
mirror of https://github.com/dragonflyoss/dragonfly.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: replace grpc package with https://github.com/dragonflyoss/api (#1515) 

Signed-off-by: Gaius <gaius.qi@gmail.com>
Co-authored-by: Jim Ma <majinjing3@gmail.com>
This commit is contained in:
Gaius 2022-08-02 17:31:39 +08:00
parent a41a524f4c
commit d79f6405ff
No known key found for this signature in database
GPG Key ID: 8B4E5D1290FA2FFB
127 changed files with 1696 additions and 18536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.golangci.yml
View File

@ -9,6 +9,7 @@ linters-settings:
sections:
- standard
- default
- prefix(d7y.io/api)
- prefix(d7y.io/dragonfly/v2)
issues:

6
Makefile
View File

@ -375,11 +375,6 @@ generate:
@go generate ${PKG_LIST}
.PHONY: generate
# Generate grpc protos
protoc:
@./hack/protoc.sh
.PHONY: protoc
# Generate swagger files
swag:
@swag init --parseDependency --parseInternal -g cmd/manager/main.go -o api/manager
@ -441,7 +436,6 @@ help:
@echo "make lint run code lint"
@echo "make markdownlint run markdown lint"
@echo "make generate run go generate"
@echo "make protoc generate grpc protos"
@echo "make swag generate swagger api docs"
@echo "make changelog generate CHANGELOG.md"
@echo "make clean clean"

23
client/config/dynconfig.go
View File

@ -26,10 +26,11 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
internaldynconfig "d7y.io/dragonfly/v2/internal/dynconfig"
"d7y.io/dragonfly/v2/manager/searcher"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
managerclient "d7y.io/dragonfly/v2/pkg/rpc/manager/client"
)
@ -42,16 +43,16 @@ var (
)
type DynconfigData struct {
Schedulers []*manager.Scheduler
ObjectStorage *manager.ObjectStorage
Schedulers []*managerv1.Scheduler
ObjectStorage *managerv1.ObjectStorage
}
type Dynconfig interface {
// Get the dynamic schedulers config from manager.
GetSchedulers() ([]*manager.Scheduler, error)
GetSchedulers() ([]*managerv1.Scheduler, error)
// Get the dynamic object storage config from manager.
GetObjectStorage() (*manager.ObjectStorage, error)
GetObjectStorage() (*managerv1.ObjectStorage, error)
// Get the dynamic config from manager.
Get() (*DynconfigData, error)
@ -104,7 +105,7 @@ func NewDynconfig(rawManagerClient managerclient.Client, cacheDir string, hostOp
}, nil
}
func (d *dynconfig) GetSchedulers() ([]*manager.Scheduler, error) {
func (d *dynconfig) GetSchedulers() ([]*managerv1.Scheduler, error) {
data, err := d.Get()
if err != nil {
return nil, err
@ -113,7 +114,7 @@ func (d *dynconfig) GetSchedulers() ([]*manager.Scheduler, error) {
return data.Schedulers, nil
}
func (d *dynconfig) GetObjectStorage() (*manager.ObjectStorage, error) {
func (d *dynconfig) GetObjectStorage() (*managerv1.ObjectStorage, error) {
data, err := d.Get()
if err != nil {
return nil, err
@ -200,8 +201,8 @@ func newManagerClient(client managerclient.Client, hostOption HostOption) intern
}
func (mc *managerClient) Get() (any, error) {
listSchedulersResp, err := mc.ListSchedulers(&manager.ListSchedulersRequest{
SourceType: manager.SourceType_PEER_SOURCE,
listSchedulersResp, err := mc.ListSchedulers(&managerv1.ListSchedulersRequest{
SourceType: managerv1.SourceType_PEER_SOURCE,
HostName: mc.hostOption.Hostname,
Ip: mc.hostOption.AdvertiseIP,
HostInfo: map[string]string{
@ -215,8 +216,8 @@ func (mc *managerClient) Get() (any, error) {
return nil, err
}
getObjectStorageResp, err := mc.GetObjectStorage(&manager.GetObjectStorageRequest{
SourceType: manager.SourceType_PEER_SOURCE,
getObjectStorageResp, err := mc.GetObjectStorage(&managerv1.GetObjectStorageRequest{
SourceType: managerv1.SourceType_PEER_SOURCE,
HostName: mc.hostOption.Hostname,
Ip: mc.hostOption.AdvertiseIP,
})

171
client/config/dynconfig_test.go
View File

@ -28,7 +28,8 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
"d7y.io/dragonfly/v2/pkg/rpc/manager/client/mocks"
)
@ -57,8 +58,8 @@ func TestDynconfigNewDynconfig(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, err error) {
@ -77,8 +78,8 @@ func TestDynconfigNewDynconfig(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, err error) {
@ -106,7 +107,7 @@ func TestDynconfigNewDynconfig(t *testing.T) {
cleanFileCache: func(t *testing.T) {},
mock: func(m *mocks.MockClientMockRecorder) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(nil, errors.New("foo")).Times(1),
)
},
@ -126,7 +127,7 @@ func TestDynconfigNewDynconfig(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(nil, status.Error(codes.NotFound, "")).Times(1),
)
},
@ -185,12 +186,12 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
},
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -202,14 +203,14 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
)
@ -228,12 +229,12 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
},
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -247,16 +248,16 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
)
@ -275,12 +276,12 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
},
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -294,14 +295,14 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(nil, errors.New("foo")).Times(1),
@ -321,12 +322,12 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
},
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -340,17 +341,17 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(nil, errors.New("foo")).Times(1),
)
},
@ -368,12 +369,12 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
},
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -387,18 +388,18 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
@ -412,7 +413,7 @@ func TestDynconfigGet(t *testing.T) {
result, err := dynconfig.Get()
assert.NoError(err)
assert.EqualValues(result, &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
@ -427,8 +428,8 @@ func TestDynconfigGet(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler(nil),
ObjectStorage: &manager.ObjectStorage{},
Schedulers: []*managerv1.Scheduler(nil),
ObjectStorage: &managerv1.ObjectStorage{},
},
sleep: func() {
time.Sleep(100 * time.Millisecond)
@ -440,10 +441,10 @@ func TestDynconfigGet(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
@ -495,7 +496,7 @@ func TestDynconfigGetSchedulers(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
@ -509,14 +510,14 @@ func TestDynconfigGetSchedulers(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
@ -533,7 +534,7 @@ func TestDynconfigGetSchedulers(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
@ -549,16 +550,16 @@ func TestDynconfigGetSchedulers(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
@ -575,7 +576,7 @@ func TestDynconfigGetSchedulers(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler{
Schedulers: []*managerv1.Scheduler{
{
HostName: "foo",
},
@ -591,14 +592,14 @@ func TestDynconfigGetSchedulers(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{
Schedulers: []*manager.Scheduler{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{
Schedulers: []*managerv1.Scheduler{
{
HostName: data.Schedulers[0].HostName,
},
},
}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(nil, errors.New("foo")).Times(1),
)
},
@ -616,7 +617,7 @@ func TestDynconfigGetSchedulers(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
Schedulers: []*manager.Scheduler(nil),
Schedulers: []*managerv1.Scheduler(nil),
},
sleep: func() {
time.Sleep(100 * time.Millisecond)
@ -628,10 +629,10 @@ func TestDynconfigGetSchedulers(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
@ -683,7 +684,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -695,8 +696,8 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
)
@ -715,7 +716,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -729,10 +730,10 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
)
@ -751,7 +752,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -765,11 +766,11 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(nil, errors.New("foo")).Times(1),
)
},
@ -787,7 +788,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
ObjectStorage: &manager.ObjectStorage{
ObjectStorage: &managerv1.ObjectStorage{
Name: "foo",
},
},
@ -801,11 +802,11 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{
Name: data.ObjectStorage.Name,
}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(nil, status.Error(codes.NotFound, "")).Times(1),
)
},
@ -813,7 +814,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
assert := assert.New(t)
result, err := dynconfig.GetObjectStorage()
assert.NoError(err)
assert.EqualValues(result, (*manager.ObjectStorage)(nil))
assert.EqualValues(result, (*managerv1.ObjectStorage)(nil))
},
},
{
@ -823,7 +824,7 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
Hostname: "foo",
},
data: &DynconfigData{
ObjectStorage: &manager.ObjectStorage{},
ObjectStorage: &managerv1.ObjectStorage{},
},
sleep: func() {
time.Sleep(100 * time.Millisecond)
@ -835,10 +836,10 @@ func TestDynconfigGetObjectStorage(t *testing.T) {
},
mock: func(m *mocks.MockClientMockRecorder, data *DynconfigData) {
gomock.InOrder(
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&manager.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&manager.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
m.ListSchedulers(gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
m.GetObjectStorage(gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
)
},
expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {

10
client/config/mocks/dynconfig_mock.go
View File

@ -7,8 +7,8 @@ package mocks
import (
reflect "reflect"
v1 "d7y.io/api/pkg/apis/manager/v1"
config "d7y.io/dragonfly/v2/client/config"
manager "d7y.io/dragonfly/v2/pkg/rpc/manager"
gomock "github.com/golang/mock/gomock"
)
@ -63,10 +63,10 @@ func (mr *MockDynconfigMockRecorder) Get() *gomock.Call {
}
// GetObjectStorage mocks base method.
func (m *MockDynconfig) GetObjectStorage() (*manager.ObjectStorage, error) {
func (m *MockDynconfig) GetObjectStorage() (*v1.ObjectStorage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetObjectStorage")
ret0, _ := ret[0].(*manager.ObjectStorage)
ret0, _ := ret[0].(*v1.ObjectStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -78,10 +78,10 @@ func (mr *MockDynconfigMockRecorder) GetObjectStorage() *gomock.Call {
}
// GetSchedulers mocks base method.
func (m *MockDynconfig) GetSchedulers() ([]*manager.Scheduler, error) {
func (m *MockDynconfig) GetSchedulers() ([]*v1.Scheduler, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSchedulers")
ret0, _ := ret[0].([]*manager.Scheduler)
ret0, _ := ret[0].([]*v1.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}

13
client/config/peerhost.go
View File

@ -33,12 +33,13 @@ import (
"gopkg.in/yaml.v3"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/util"
"d7y.io/dragonfly/v2/cmd/dependency/base"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
netip "d7y.io/dragonfly/v2/pkg/net/ip"
rpcbase "d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/unit"
)
@ -156,18 +157,18 @@ func (p *DaemonOption) Validate() error {
return nil
}
func ConvertPattern(p string, defaultPattern rpcbase.Pattern) rpcbase.Pattern {
func ConvertPattern(p string, defaultPattern commonv1.Pattern) commonv1.Pattern {
switch p {
case PatternP2P:
return rpcbase.Pattern_P2P
return commonv1.Pattern_P2P
case PatternSeedPeer:
return rpcbase.Pattern_SEED_PEER
return commonv1.Pattern_SEED_PEER
case PatternSource:
return rpcbase.Pattern_SOURCE
return commonv1.Pattern_SOURCE
case "":
return defaultPattern
}
logger.Warnf("unknown pattern, use default pattern: %s", rpcbase.Pattern_name[int32(defaultPattern)])
logger.Warnf("unknown pattern, use default pattern: %s", commonv1.Pattern_name[int32(defaultPattern)])
return defaultPattern
}

43
client/daemon/daemon.go
View File

@ -37,6 +37,10 @@ import (
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
commonv1 "d7y.io/api/pkg/apis/common/v1"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/gc"
"d7y.io/dragonfly/v2/client/daemon/metrics"
@ -54,10 +58,7 @@ import (
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/reachable"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
managerclient "d7y.io/dragonfly/v2/pkg/rpc/manager/client"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
schedulerclient "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client"
"d7y.io/dragonfly/v2/pkg/source"
)
@ -68,15 +69,15 @@ type Daemon interface {
// ExportTaskManager returns the underlay peer.TaskManager for downloading when embed dragonfly in custom binary
ExportTaskManager() peer.TaskManager
// ExportPeerHost returns the underlay scheduler.PeerHost for scheduling
ExportPeerHost() *scheduler.PeerHost
// ExportPeerHost returns the underlay schedulerv1.PeerHost for scheduling
ExportPeerHost() *schedulerv1.PeerHost
}
type clientDaemon struct {
once *sync.Once
done chan bool
schedPeerHost *scheduler.PeerHost
schedPeerHost *schedulerv1.PeerHost
Option config.DaemonOption
@ -92,7 +93,7 @@ type clientDaemon struct {
dynconfig config.Dynconfig
dfpath dfpath.Dfpath
schedulers []*manager.Scheduler
schedulers []*managerv1.Scheduler
managerClient managerclient.Client
schedulerClient schedulerclient.Client
}
@ -101,7 +102,7 @@ func New(opt *config.DaemonOption, d dfpath.Dfpath) (Daemon, error) {
// update plugin directory
source.UpdatePluginDir(d.PluginDir())
host := &scheduler.PeerHost{
host := &schedulerv1.PeerHost{
Id: idgen.HostID(opt.Host.Hostname, int32(opt.Download.PeerGRPC.TCPListen.PortRange.Start)),
Ip: opt.Host.AdvertiseIP,
RpcPort: int32(opt.Download.PeerGRPC.TCPListen.PortRange.Start),
@ -115,10 +116,10 @@ func New(opt *config.DaemonOption, d dfpath.Dfpath) (Daemon, error) {
var (
addrs []dfnet.NetAddr
schedulers []*manager.Scheduler
schedulers []*managerv1.Scheduler
dynconfig config.Dynconfig
managerClient managerclient.Client
defaultPattern = config.ConvertPattern(opt.Download.DefaultPattern, base.Pattern_P2P)
defaultPattern = config.ConvertPattern(opt.Download.DefaultPattern, commonv1.Pattern_P2P)
)
if opt.Scheduler.Manager.Enable {
@ -162,7 +163,7 @@ func New(opt *config.DaemonOption, d dfpath.Dfpath) (Daemon, error) {
// Storage.Option.DataPath is same with Daemon DataDir
opt.Storage.DataPath = d.DataDir()
gcCallback := func(request storage.CommonTaskRequest) {
er := sched.LeaveTask(context.Background(), &scheduler.PeerTarget{
er := sched.LeaveTask(context.Background(), &schedulerv1.PeerTarget{
TaskId: request.TaskID,
PeerId: request.PeerID,
})
@ -524,8 +525,8 @@ func (cd *clientDaemon) Serve() error {
g.Go(func() error {
logger.Info("keepalive to manager")
cd.managerClient.KeepAlive(cd.Option.Scheduler.Manager.SeedPeer.KeepAlive.Interval, &manager.KeepAliveRequest{
SourceType: manager.SourceType_SEED_PEER_SOURCE,
cd.managerClient.KeepAlive(cd.Option.Scheduler.Manager.SeedPeer.KeepAlive.Interval, &managerv1.KeepAliveRequest{
SourceType: managerv1.SourceType_SEED_PEER_SOURCE,
HostName: cd.Option.Host.Hostname,
Ip: cd.Option.Host.AdvertiseIP,
ClusterId: uint64(cd.Option.Scheduler.Manager.SeedPeer.ClusterID),
@ -564,7 +565,7 @@ func (cd *clientDaemon) Serve() error {
}
// serve dynconfig service
if cd.dynconfig != nil {
if cd.Option.Scheduler.Manager.Enable {
// dynconfig register client daemon
cd.dynconfig.Register(cd)
@ -662,7 +663,7 @@ func (cd *clientDaemon) Stop() {
cd.StorageManager.CleanUp()
}
if cd.dynconfig != nil {
if cd.Option.Scheduler.Manager.Enable {
if err := cd.dynconfig.Stop(); err != nil {
logger.Errorf("dynconfig client closed failed %s", err)
}
@ -697,7 +698,7 @@ func (cd *clientDaemon) OnNotify(data *config.DynconfigData) {
}
// getSchedulerIPs gets ips by schedulers.
func getSchedulerIPs(schedulers []*manager.Scheduler) []string {
func getSchedulerIPs(schedulers []*managerv1.Scheduler) []string {
ips := []string{}
for _, scheduler := range schedulers {
ips = append(ips, scheduler.Ip)
@ -706,8 +707,8 @@ func getSchedulerIPs(schedulers []*manager.Scheduler) []string {
return ips
}
// schedulersToAvailableNetAddrs coverts []*manager.Scheduler to available []dfnet.NetAddr.
func schedulersToAvailableNetAddrs(schedulers []*manager.Scheduler) []dfnet.NetAddr {
// schedulersToAvailableNetAddrs coverts []*managerv1.Scheduler to available []dfnet.NetAddr.
func schedulersToAvailableNetAddrs(schedulers []*managerv1.Scheduler) []dfnet.NetAddr {
var schedulerClusterID uint64
netAddrs := make([]dfnet.NetAddr, 0, len(schedulers))
for _, scheduler := range schedulers {
@ -752,8 +753,8 @@ func (cd *clientDaemon) announceSeedPeer() error {
objectStoragePort = int32(cd.Option.ObjectStorage.TCPListen.PortRange.Start)
}
if _, err := cd.managerClient.UpdateSeedPeer(&manager.UpdateSeedPeerRequest{
SourceType: manager.SourceType_SEED_PEER_SOURCE,
if _, err := cd.managerClient.UpdateSeedPeer(&managerv1.UpdateSeedPeerRequest{
SourceType: managerv1.SourceType_SEED_PEER_SOURCE,
HostName: cd.Option.Host.Hostname,
Type: cd.Option.Scheduler.Manager.SeedPeer.Type,
Idc: cd.Option.Host.IDC,
@ -775,6 +776,6 @@ func (cd *clientDaemon) ExportTaskManager() peer.TaskManager {
return cd.PeerTaskManager
}
func (cd *clientDaemon) ExportPeerHost() *scheduler.PeerHost {
func (cd *clientDaemon) ExportPeerHost() *schedulerv1.PeerHost {
return cd.schedPeerHost
}

21
client/daemon/daemon_test.go
View File

@ -22,8 +22,9 @@ import (
"github.com/stretchr/testify/assert"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
@ -35,12 +36,12 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
tests := []struct {
name string
schedulers []*manager.Scheduler
schedulers []*managerv1.Scheduler
expect func(t *testing.T, addrs []dfnet.NetAddr)
}{
{
name: "available ip",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "127.0.0.1",
Port: int32(3000),
@ -59,7 +60,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "available host",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "foo",
HostName: "localhost",
@ -80,7 +81,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "available ip and host",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "foo",
HostName: "localhost",
@ -122,7 +123,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "unreachable",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "foo",
HostName: "localhost",
@ -143,7 +144,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "empty schedulers",
schedulers: []*manager.Scheduler{},
schedulers: []*managerv1.Scheduler{},
expect: func(t *testing.T, addrs []dfnet.NetAddr) {
assert := assert.New(t)
assert.EqualValues(addrs, []dfnet.NetAddr{})
@ -151,7 +152,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "available ip with different scheduler cluster",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "127.0.0.1",
HostName: "foo",
@ -181,7 +182,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "available host with different scheduler cluster",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "127.0.0.1",
HostName: "foo",
@ -211,7 +212,7 @@ func TestDaemonSchedulersToAvailableNetAddrs(t *testing.T) {
},
{
name: "available host and ip with different scheduler cluster",
schedulers: []*manager.Scheduler{
schedulers: []*managerv1.Scheduler{
{
Ip: "foo",
HostName: "localhost",

9
client/daemon/objectstorage/objectstorage.go
View File

@ -40,6 +40,8 @@ import (
ginprometheus "github.com/mcuadros/go-gin-prometheus"
"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/daemon/storage"
@ -48,7 +50,6 @@ import (
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/objectstorage"
"d7y.io/dragonfly/v2/pkg/rpc/base"
pkgstrings "d7y.io/dragonfly/v2/pkg/strings"
)
@ -251,7 +252,7 @@ func (o *objectStorage) getObject(ctx *gin.Context) {
)
// Initialize filter field.
urlMeta := &base.UrlMeta{Filter: o.config.ObjectStorage.Filter}
urlMeta := &commonv1.UrlMeta{Filter: o.config.ObjectStorage.Filter}
if filter != "" {
urlMeta.Filter = filter
}
@ -387,7 +388,7 @@ func (o *objectStorage) putObject(ctx *gin.Context) {
}
// Initialize url meta.
urlMeta := &base.UrlMeta{Filter: o.config.ObjectStorage.Filter}
urlMeta := &commonv1.UrlMeta{Filter: o.config.ObjectStorage.Filter}
dgst := o.md5FromFileHeader(fileHeader)
urlMeta.Digest = dgst.String()
if filter != "" {
@ -419,7 +420,7 @@ func (o *objectStorage) putObject(ctx *gin.Context) {
if err := o.peerTaskManager.AnnouncePeerTask(ctx, storage.PeerTaskMetadata{
TaskID: taskID,
PeerID: peerID,
}, signURL, base.TaskType_DfStore, urlMeta); err != nil {
}, signURL, commonv1.TaskType_DfStore, urlMeta); err != nil {
log.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"errors": err.Error()})
return

187
client/daemon/peer/peertask_conductor.go
View File

@ -33,6 +33,10 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
errordetailsv1 "d7y.io/api/pkg/apis/errordetails/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/storage"
@ -41,9 +45,6 @@ import (
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/errordetails"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
schedulerclient "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client"
"d7y.io/dragonfly/v2/pkg/source"
)
@ -76,9 +77,9 @@ type peerTaskConductor struct {
pieceDownloadCancel context.CancelFunc
// host info about current host
host *scheduler.PeerHost
host *schedulerv1.PeerHost
// request is the original PeerTaskRequest
request *scheduler.PeerTaskRequest
request *schedulerv1.PeerTaskRequest
// needBackSource indicates downloading resource from instead of other peers
needBackSource *atomic.Bool
@ -107,15 +108,15 @@ type peerTaskConductor struct {
broker *pieceBroker
sizeScope base.SizeScope
singlePiece *scheduler.SinglePiece
sizeScope commonv1.SizeScope
singlePiece *schedulerv1.SinglePiece
tinyData *TinyData
// peerPacketStream stands schedulerclient.PeerPacketStream from scheduler
peerPacketStream scheduler.Scheduler_ReportPieceResultClient
peerPacketStream schedulerv1.Scheduler_ReportPieceResultClient
// peerPacket is the latest available peers from peerPacketCh
// Deprecated: remove in future release
peerPacket atomic.Value // *scheduler.PeerPacket
peerPacket atomic.Value // *schedulerv1.PeerPacket
legacyPeerCount *atomic.Int64
// peerPacketReady will receive a ready signal for peerPacket ready
peerPacketReady chan bool
@ -141,7 +142,7 @@ type peerTaskConductor struct {
// failedReason will be set when peer task failed
failedReason string
// failedReason will be set when peer task failed
failedCode base.Code
failedCode commonv1.Code
// readyPieces stands all downloaded pieces
readyPieces *Bitmap
@ -171,7 +172,7 @@ type peerTaskConductor struct {
func (ptm *peerTaskManager) newPeerTaskConductor(
ctx context.Context,
request *scheduler.PeerTaskRequest,
request *schedulerv1.PeerTaskRequest,
limit rate.Limit,
parent *peerTaskConductor,
rg *util.Range,
@ -229,7 +230,7 @@ func (ptm *peerTaskManager) newPeerTaskConductor(
requestedPieces: NewBitmap(),
failedPieceCh: make(chan int32, config.DefaultPieceChanSize),
failedReason: failedReasonNotSet,
failedCode: base.Code_UnknownError,
failedCode: commonv1.Code_UnknownError,
contentLength: atomic.NewInt64(-1),
totalPiece: atomic.NewInt32(-1),
digest: atomic.NewString(""),
@ -265,8 +266,8 @@ func (pt *peerTaskConductor) register() error {
var (
needBackSource bool
sizeScope base.SizeScope
singlePiece *scheduler.SinglePiece
sizeScope commonv1.SizeScope
singlePiece *schedulerv1.SinglePiece
tinyData *TinyData
)
@ -287,35 +288,35 @@ func (pt *peerTaskConductor) register() error {
pt.peerPacketStream = &dummyPeerPacketStream{}
pt.Errorf("register peer task failed: %s, peer id: %s, auto back source disabled", err, pt.request.PeerId)
pt.span.RecordError(err)
pt.cancel(base.Code_SchedError, err.Error())
pt.cancel(commonv1.Code_SchedError, err.Error())
return err
}
needBackSource = true
// can not detect source or scheduler error, create a new dummy scheduler client
pt.schedulerClient = &dummySchedulerClient{}
result = &scheduler.RegisterResult{TaskId: pt.taskID}
result = &schedulerv1.RegisterResult{TaskId: pt.taskID}
pt.Warnf("register peer task failed: %s, peer id: %s, try to back source", err, pt.request.PeerId)
} else {
pt.Infof("register task success, SizeScope: %s", base.SizeScope_name[int32(result.SizeScope)])
pt.Infof("register task success, SizeScope: %s", commonv1.SizeScope_name[int32(result.SizeScope)])
}
var header map[string]string
if !needBackSource {
sizeScope = result.SizeScope
switch result.SizeScope {
case base.SizeScope_NORMAL:
case commonv1.SizeScope_NORMAL:
pt.span.SetAttributes(config.AttributePeerTaskSizeScope.String("normal"))
case base.SizeScope_SMALL:
case commonv1.SizeScope_SMALL:
pt.span.SetAttributes(config.AttributePeerTaskSizeScope.String("small"))
if piece, ok := result.DirectPiece.(*scheduler.RegisterResult_SinglePiece); ok {
if piece, ok := result.DirectPiece.(*schedulerv1.RegisterResult_SinglePiece); ok {
singlePiece = piece.SinglePiece
}
if result.ExtendAttribute != nil {
header = result.ExtendAttribute.Header
}
case base.SizeScope_TINY:
case commonv1.SizeScope_TINY:
pt.span.SetAttributes(config.AttributePeerTaskSizeScope.String("tiny"))
if piece, ok := result.DirectPiece.(*scheduler.RegisterResult_PieceContent); ok {
if piece, ok := result.DirectPiece.(*schedulerv1.RegisterResult_PieceContent); ok {
tinyData = &TinyData{
TaskID: result.TaskId,
PeerID: pt.request.PeerId,
@ -327,7 +328,7 @@ func (pt *peerTaskConductor) register() error {
pt.peerPacketStream = &dummyPeerPacketStream{}
pt.span.RecordError(err)
pt.Errorf("%s", err)
pt.cancel(base.Code_SchedError, err.Error())
pt.cancel(commonv1.Code_SchedError, err.Error())
return err
}
if result.ExtendAttribute != nil {
@ -342,7 +343,7 @@ func (pt *peerTaskConductor) register() error {
// when peer register failed, some actions need to do with peerPacketStream
pt.peerPacketStream = &dummyPeerPacketStream{}
pt.span.RecordError(err)
pt.cancel(base.Code_SchedError, err.Error())
pt.cancel(commonv1.Code_SchedError, err.Error())
return err
}
@ -363,7 +364,7 @@ func (pt *peerTaskConductor) start() error {
if pt.seed {
pt.peerPacketStream = &dummyPeerPacketStream{}
pt.schedulerClient = &dummySchedulerClient{}
pt.sizeScope = base.SizeScope_NORMAL
pt.sizeScope = commonv1.SizeScope_NORMAL
pt.needBackSource = atomic.NewBool(true)
} else {
// register to scheduler
@ -449,7 +450,7 @@ func (pt *peerTaskConductor) UpdateSourceErrorStatus(st *status.Status) {
pt.sourceErrorStatus = st
}
func (pt *peerTaskConductor) cancel(code base.Code, reason string) {
func (pt *peerTaskConductor) cancel(code commonv1.Code, reason string) {
pt.statusOnce.Do(func() {
pt.failedCode = code
pt.failedReason = reason
@ -463,19 +464,19 @@ func (pt *peerTaskConductor) markBackSource() {
// when close peerPacketReady, pullPiecesFromPeers will invoke backSource
close(pt.peerPacketReady)
// let legacy mode exit
pt.peerPacket.Store(&scheduler.PeerPacket{
pt.peerPacket.Store(&schedulerv1.PeerPacket{
TaskId: pt.taskID,
SrcPid: pt.peerID,
ParallelCount: 1,
MainPeer: nil,
CandidatePeers: []*scheduler.PeerPacket_DestPeer{
CandidatePeers: []*schedulerv1.PeerPacket_DestPeer{
{
Ip: pt.host.Ip,
RpcPort: pt.host.RpcPort,
PeerId: pt.peerID,
},
},
Code: base.Code_SchedNeedBackSource,
Code: commonv1.Code_SchedNeedBackSource,
})
}
@ -501,9 +502,9 @@ func (pt *peerTaskConductor) backSource() {
span.SetAttributes(config.AttributePeerTaskSuccess.Bool(false))
span.RecordError(err)
if isBackSourceError(err) {
pt.cancel(base.Code_ClientBackSourceError, err.Error())
pt.cancel(commonv1.Code_ClientBackSourceError, err.Error())
} else {
pt.cancel(base.Code_ClientError, err.Error())
pt.cancel(commonv1.Code_ClientError, err.Error())
}
span.End()
return
@ -521,14 +522,14 @@ func (pt *peerTaskConductor) pullPieces() {
return
}
switch pt.sizeScope {
case base.SizeScope_TINY:
case commonv1.SizeScope_TINY:
pt.storeTinyPeerTask()
case base.SizeScope_SMALL:
case commonv1.SizeScope_SMALL:
pt.pullSinglePiece()
case base.SizeScope_NORMAL:
case commonv1.SizeScope_NORMAL:
pt.pullPiecesWithP2P()
default:
pt.cancel(base.Code_ClientError, fmt.Sprintf("unknown size scope: %d", pt.sizeScope))
pt.cancel(commonv1.Code_ClientError, fmt.Sprintf("unknown size scope: %d", pt.sizeScope))
}
}
@ -571,7 +572,7 @@ func (pt *peerTaskConductor) storeTinyPeerTask() {
pt.storage = storageDriver
if err != nil {
pt.Errorf("register tiny data storage failed: %s", err)
pt.cancel(base.Code_ClientError, err.Error())
pt.cancel(commonv1.Code_ClientError, err.Error())
return
}
n, err := pt.GetStorage().WritePiece(ctx,
@ -598,19 +599,19 @@ func (pt *peerTaskConductor) storeTinyPeerTask() {
})
if err != nil {
pt.Errorf("write tiny data storage failed: %s", err)
pt.cancel(base.Code_ClientError, err.Error())
pt.cancel(commonv1.Code_ClientError, err.Error())
return
}
if n != contentLength {
pt.Errorf("write tiny data storage failed, want: %d, wrote: %d", contentLength, n)
pt.cancel(base.Code_ClientError, err.Error())
pt.cancel(commonv1.Code_ClientError, err.Error())
return
}
err = pt.UpdateStorage()
if err != nil {
pt.Errorf("update tiny data storage failed: %s", err)
pt.cancel(base.Code_ClientError, err.Error())
pt.cancel(commonv1.Code_ClientError, err.Error())
return
}
@ -621,7 +622,7 @@ func (pt *peerTaskConductor) storeTinyPeerTask() {
func (pt *peerTaskConductor) receivePeerPacket(pieceRequestCh chan *DownloadPieceRequest) {
var (
lastNotReadyPiece int32 = 0
peerPacket *scheduler.PeerPacket
peerPacket *schedulerv1.PeerPacket
err error
firstPacketReceived bool
)
@ -669,8 +670,8 @@ loop:
}
pt.Debugf("receive peerPacket %v", peerPacket)
if peerPacket.Code != base.Code_Success {
if peerPacket.Code == base.Code_SchedNeedBackSource {
if peerPacket.Code != commonv1.Code_Success {
if peerPacket.Code == commonv1.Code_SchedNeedBackSource {
pt.markBackSource()
pt.Infof("receive back source code")
return
@ -737,8 +738,8 @@ loop:
}
}
// updateSynchronizer will convert peers to synchronizer, if failed, will update failed peers to scheduler.PeerPacket
func (pt *peerTaskConductor) updateSynchronizer(lastNum int32, p *scheduler.PeerPacket) int32 {
// updateSynchronizer will convert peers to synchronizer, if failed, will update failed peers to schedulerv1.PeerPacket
func (pt *peerTaskConductor) updateSynchronizer(lastNum int32, p *schedulerv1.PeerPacket) int32 {
desiredPiece, ok := pt.getNextNotReadyPieceNum(lastNum)
if !ok {
pt.Infof("all pieces is ready, peer task completed, skip to synchronize")
@ -746,7 +747,7 @@ func (pt *peerTaskConductor) updateSynchronizer(lastNum int32, p *scheduler.Peer
p.CandidatePeers = nil
return desiredPiece
}
var peers = []*scheduler.PeerPacket_DestPeer{p.MainPeer}
var peers = []*schedulerv1.PeerPacket_DestPeer{p.MainPeer}
peers = append(peers, p.CandidatePeers...)
legacyPeers := pt.pieceTaskSyncManager.newMultiPieceTaskSynchronizer(peers, desiredPiece)
@ -765,15 +766,15 @@ func (pt *peerTaskConductor) confirmReceivePeerPacketError(err error) {
default:
}
var (
failedCode = base.Code_UnknownError
failedCode = commonv1.Code_UnknownError
failedReason string
)
de, ok := err.(*dferrors.DfError)
if ok && de.Code == base.Code_SchedNeedBackSource {
if ok && de.Code == commonv1.Code_SchedNeedBackSource {
pt.markBackSource()
pt.Infof("receive back source code")
return
} else if ok && de.Code != base.Code_SchedNeedBackSource {
} else if ok && de.Code != commonv1.Code_SchedNeedBackSource {
failedCode = de.Code
failedReason = de.Message
pt.Errorf("receive peer packet failed: %s", pt.failedReason)
@ -784,29 +785,29 @@ func (pt *peerTaskConductor) confirmReceivePeerPacketError(err error) {
return
}
func (pt *peerTaskConductor) isExitPeerPacketCode(pp *scheduler.PeerPacket) bool {
func (pt *peerTaskConductor) isExitPeerPacketCode(pp *schedulerv1.PeerPacket) bool {
switch pp.Code {
case base.Code_ResourceLacked, base.Code_BadRequest,
base.Code_PeerTaskNotFound, base.Code_UnknownError, base.Code_RequestTimeOut:
case commonv1.Code_ResourceLacked, commonv1.Code_BadRequest,
commonv1.Code_PeerTaskNotFound, commonv1.Code_UnknownError, commonv1.Code_RequestTimeOut:
// 1xxx
pt.failedCode = pp.Code
pt.failedReason = fmt.Sprintf("receive exit peer packet with code %d", pp.Code)
return true
case base.Code_SchedError, base.Code_SchedTaskStatusError, base.Code_SchedPeerNotFound:
case commonv1.Code_SchedError, commonv1.Code_SchedTaskStatusError, commonv1.Code_SchedPeerNotFound:
// 5xxx
pt.failedCode = pp.Code
pt.failedReason = fmt.Sprintf("receive exit peer packet with code %d", pp.Code)
return true
case base.Code_SchedPeerGone:
case commonv1.Code_SchedPeerGone:
pt.failedReason = reasonPeerGoneFromScheduler
pt.failedCode = base.Code_SchedPeerGone
pt.failedCode = commonv1.Code_SchedPeerGone
return true
case base.Code_CDNTaskRegistryFail:
case commonv1.Code_CDNTaskRegistryFail:
// 6xxx
pt.failedCode = pp.Code
pt.failedReason = fmt.Sprintf("receive exit peer packet with code %d", pp.Code)
return true
case base.Code_BackToSourceAborted:
case commonv1.Code_BackToSourceAborted:
st := status.Newf(codes.Aborted, "response is not valid")
st, err := st.WithDetails(pp.GetSourceError())
if err != nil {
@ -877,7 +878,7 @@ func (pt *peerTaskConductor) pullPiecesFromPeers(pieceRequestCh chan *DownloadPi
)
// ensure first peer packet is not nil
peerPacket, ok := pt.peerPacket.Load().(*scheduler.PeerPacket)
peerPacket, ok := pt.peerPacket.Load().(*schedulerv1.PeerPacket)
if !ok {
pt.Warn("pull pieces canceled")
return
@ -912,7 +913,7 @@ loop:
// 2, try to get pieces
pt.Debugf("try to get pieces, number: %d, limit: %d", num, limit)
piecePacket, err := pt.pieceTaskPoller.preparePieceTasks(
&base.PieceTaskRequest{
&commonv1.PieceTaskRequest{
TaskId: pt.taskID,
SrcPid: pt.peerID,
StartNum: uint32(num),
@ -953,7 +954,7 @@ loop:
}
}
func (pt *peerTaskConductor) updateMetadata(piecePacket *base.PiecePacket) {
func (pt *peerTaskConductor) updateMetadata(piecePacket *commonv1.PiecePacket) {
// update total piece
var metadataChanged bool
if piecePacket.TotalPiece > pt.GetTotalPieces() {
@ -1013,17 +1014,17 @@ func (pt *peerTaskConductor) waitFirstPeerPacket() (done bool, backSource bool)
if ok {
// preparePieceTasksByPeer func already send piece result with error
pt.Infof("new peer client ready, scheduler time cost: %dus, peer count: %d",
time.Since(pt.startTime).Microseconds(), len(pt.peerPacket.Load().(*scheduler.PeerPacket).CandidatePeers))
time.Since(pt.startTime).Microseconds(), len(pt.peerPacket.Load().(*schedulerv1.PeerPacket).CandidatePeers))
return true, false
}
// when scheduler says base.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to base.Code_SchedNeedBackSource")
// when scheduler says commonv1.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to commonv1.Code_SchedNeedBackSource")
pt.span.AddEvent("back source due to scheduler says need back source")
pt.backSource()
return false, true
case <-time.After(pt.schedulerOption.ScheduleTimeout.Duration):
if pt.schedulerOption.DisableAutoBackSource {
pt.cancel(base.Code_ClientScheduleTimeout, reasonBackSourceDisabled)
pt.cancel(commonv1.Code_ClientScheduleTimeout, reasonBackSourceDisabled)
err := fmt.Errorf("%s, auto back source disabled", pt.failedReason)
pt.span.RecordError(err)
pt.Errorf(err.Error())
@ -1048,12 +1049,12 @@ func (pt *peerTaskConductor) waitAvailablePeerPacket() (int32, bool) {
case _, ok := <-pt.peerPacketReady:
if ok {
// preparePieceTasksByPeer func already send piece result with error
pt.Infof("new peer client ready, peer count: %d", len(pt.peerPacket.Load().(*scheduler.PeerPacket).CandidatePeers))
pt.Infof("new peer client ready, peer count: %d", len(pt.peerPacket.Load().(*schedulerv1.PeerPacket).CandidatePeers))
// research from piece 0
return 0, true
}
// when scheduler says base.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to base.Code_SchedNeedBackSource")
// when scheduler says commonv1.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to commonv1.Code_SchedNeedBackSource")
pt.span.AddEvent("back source due to scheduler says need back source ")
// TODO optimize back source when already downloaded some pieces
pt.backSource()
@ -1062,7 +1063,7 @@ func (pt *peerTaskConductor) waitAvailablePeerPacket() (int32, bool) {
}
// Deprecated
func (pt *peerTaskConductor) dispatchPieceRequest(pieceRequestCh chan *DownloadPieceRequest, piecePacket *base.PiecePacket) {
func (pt *peerTaskConductor) dispatchPieceRequest(pieceRequestCh chan *DownloadPieceRequest, piecePacket *commonv1.PiecePacket) {
pieceCount := len(piecePacket.PieceInfos)
pt.Debugf("dispatch piece request, piece count: %d", pieceCount)
// fix cdn return zero piece info, but with total piece count and content length
@ -1122,8 +1123,8 @@ wait:
pt.Infof("new peer client ready, but all pieces are already downloading, just wait failed pieces")
goto wait
}
// when scheduler says base.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to base.Code_SchedNeedBackSource")
// when scheduler says commonv1.Code_SchedNeedBackSource, receivePeerPacket will close pt.peerPacketReady
pt.Infof("start download from source due to commonv1.Code_SchedNeedBackSource")
pt.span.AddEvent("back source due to scheduler says need back source")
pt.backSource()
return -1, false
@ -1199,7 +1200,7 @@ func (pt *peerTaskConductor) downloadPiece(workerID int32, request *DownloadPiec
return
}
attempt, success := pt.pieceTaskSyncManager.acquire(
&base.PieceTaskRequest{
&commonv1.PieceTaskRequest{
Limit: 1,
TaskId: pt.taskID,
SrcPid: pt.peerID,
@ -1249,13 +1250,13 @@ func (pt *peerTaskConductor) waitLimit(ctx context.Context, request *DownloadPie
waitSpan.End()
// send error piece result
sendError := pt.sendPieceResult(&scheduler.PieceResult{
sendError := pt.sendPieceResult(&schedulerv1.PieceResult{
TaskId: pt.GetTaskID(),
SrcPid: pt.GetPeerID(),
DstPid: request.DstPid,
PieceInfo: request.piece,
Success: false,
Code: base.Code_ClientRequestLimitFail,
Code: commonv1.Code_ClientRequestLimitFail,
HostLoad: nil,
FinishedCount: 0, // update by peer task
})
@ -1263,7 +1264,7 @@ func (pt *peerTaskConductor) waitLimit(ctx context.Context, request *DownloadPie
pt.Errorf("report piece result failed %s", err)
}
pt.cancel(base.Code_ClientRequestLimitFail, err.Error())
pt.cancel(commonv1.Code_ClientRequestLimitFail, err.Error())
return false
}
@ -1334,13 +1335,13 @@ func (pt *peerTaskConductor) ReportPieceResult(request *DownloadPieceRequest, re
pt.reportSuccessResult(request, result)
return
}
code := base.Code_ClientPieceDownloadFail
code := commonv1.Code_ClientPieceDownloadFail
if isConnectionError(err) {
code = base.Code_ClientConnectionError
code = commonv1.Code_ClientConnectionError
} else if isPieceNotFound(err) {
code = base.Code_ClientPieceNotFound
code = commonv1.Code_ClientPieceNotFound
} else if isBackSourceError(err) {
code = base.Code_ClientBackSourceError
code = commonv1.Code_ClientBackSourceError
}
pt.reportFailResult(request, result, code)
}
@ -1351,7 +1352,7 @@ func (pt *peerTaskConductor) reportSuccessResult(request *DownloadPieceRequest,
span.SetAttributes(config.AttributeWritePieceSuccess.Bool(true))
err := pt.sendPieceResult(
&scheduler.PieceResult{
&schedulerv1.PieceResult{
TaskId: pt.GetTaskID(),
SrcPid: pt.GetPeerID(),
DstPid: request.DstPid,
@ -1359,7 +1360,7 @@ func (pt *peerTaskConductor) reportSuccessResult(request *DownloadPieceRequest,
BeginTime: uint64(result.BeginTime),
EndTime: uint64(result.FinishTime),
Success: true,
Code: base.Code_Success,
Code: commonv1.Code_Success,
HostLoad: nil, // TODO(jim): update host load
FinishedCount: pt.readyPieces.Settled(),
// TODO range_start, range_size, piece_md5, piece_offset, piece_style
@ -1372,12 +1373,12 @@ func (pt *peerTaskConductor) reportSuccessResult(request *DownloadPieceRequest,
span.End()
}
func (pt *peerTaskConductor) reportFailResult(request *DownloadPieceRequest, result *DownloadPieceResult, code base.Code) {
func (pt *peerTaskConductor) reportFailResult(request *DownloadPieceRequest, result *DownloadPieceResult, code commonv1.Code) {
metrics.PieceTaskFailedCount.Add(1)
_, span := tracer.Start(pt.ctx, config.SpanReportPieceResult)
span.SetAttributes(config.AttributeWritePieceSuccess.Bool(false))
err := pt.sendPieceResult(&scheduler.PieceResult{
err := pt.sendPieceResult(&schedulerv1.PieceResult{
TaskId: pt.GetTaskID(),
SrcPid: pt.GetPeerID(),
DstPid: request.DstPid,
@ -1466,7 +1467,7 @@ func (pt *peerTaskConductor) done() {
var (
cost = time.Since(pt.startTime).Milliseconds()
success = true
code = base.Code_Success
code = commonv1.Code_Success
)
pt.Log().Infof("peer task done, cost: %dms", cost)
// TODO merge error handle
@ -1479,8 +1480,8 @@ func (pt *peerTaskConductor) done() {
} else {
close(pt.failCh)
success = false
code = base.Code_ClientError
pt.failedCode = base.Code_ClientError
code = commonv1.Code_ClientError
pt.failedCode = commonv1.Code_ClientError
pt.failedReason = err.Error()
pt.span.SetAttributes(config.AttributePeerTaskSuccess.Bool(false))
@ -1492,8 +1493,8 @@ func (pt *peerTaskConductor) done() {
} else {
close(pt.failCh)
success = false
code = base.Code_ClientError
pt.failedCode = base.Code_ClientError
code = commonv1.Code_ClientError
pt.failedCode = commonv1.Code_ClientError
pt.failedReason = err.Error()
pt.span.SetAttributes(config.AttributePeerTaskSuccess.Bool(false))
@ -1517,7 +1518,7 @@ func (pt *peerTaskConductor) done() {
err = pt.schedulerClient.ReportPeerResult(
peerResultCtx,
&scheduler.PeerResult{
&schedulerv1.PeerResult{
TaskId: pt.GetTaskID(),
PeerId: pt.GetPeerID(),
SrcIp: pt.host.Ip,
@ -1544,7 +1545,7 @@ func (pt *peerTaskConductor) Fail() {
}
func (pt *peerTaskConductor) fail() {
if pt.failedCode == base.Code_ClientBackSourceError {
if pt.failedCode == commonv1.Code_ClientBackSourceError {
metrics.PeerTaskFailedCount.WithLabelValues(metrics.FailTypeBackSource).Add(1)
} else {
metrics.PeerTaskFailedCount.WithLabelValues(metrics.FailTypeP2P).Add(1)
@ -1574,16 +1575,16 @@ func (pt *peerTaskConductor) fail() {
peerResultCtx, peerResultSpan := tracer.Start(ctx, config.SpanReportPeerResult)
defer peerResultSpan.End()
var sourceError *errordetails.SourceError
var sourceError *errordetailsv1.SourceError
if pt.sourceErrorStatus != nil {
for _, detail := range pt.sourceErrorStatus.Details() {
switch d := detail.(type) {
case *errordetails.SourceError:
case *errordetailsv1.SourceError:
sourceError = d
}
}
}
peerResult := &scheduler.PeerResult{
peerResult := &schedulerv1.PeerResult{
TaskId: pt.GetTaskID(),
PeerId: pt.GetPeerID(),
SrcIp: pt.peerTaskManager.host.Ip,
@ -1598,7 +1599,7 @@ func (pt *peerTaskConductor) fail() {
Code: pt.failedCode,
}
if sourceError != nil {
peerResult.ErrorDetail = &scheduler.PeerResult_SourceError{
peerResult.Errordetails = &schedulerv1.PeerResult_SourceError{
SourceError: sourceError,
}
}
@ -1672,7 +1673,7 @@ func (pt *peerTaskConductor) PublishPieceInfo(pieceNum int32, size uint32) {
})
}
func (pt *peerTaskConductor) sendPieceResult(pr *scheduler.PieceResult) error {
func (pt *peerTaskConductor) sendPieceResult(pr *schedulerv1.PieceResult) error {
pt.sendPieceResultLock.Lock()
err := pt.peerPacketStream.Send(pr)
pt.sendPieceResultLock.Unlock()

25
client/daemon/peer/peertask_dummy.go
View File

@ -21,37 +21,38 @@ import (
"google.golang.org/grpc"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
// when scheduler is not available, use dummySchedulerClient to back source
type dummySchedulerClient struct {
}
func (d *dummySchedulerClient) RegisterPeerTask(ctx context.Context, request *scheduler.PeerTaskRequest, option ...grpc.CallOption) (*scheduler.RegisterResult, error) {
func (d *dummySchedulerClient) RegisterPeerTask(ctx context.Context, request *schedulerv1.PeerTaskRequest, option ...grpc.CallOption) (*schedulerv1.RegisterResult, error) {
panic("should not call this function")
}
func (d *dummySchedulerClient) ReportPieceResult(ctx context.Context, request *scheduler.PeerTaskRequest, option ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error) {
func (d *dummySchedulerClient) ReportPieceResult(ctx context.Context, request *schedulerv1.PeerTaskRequest, option ...grpc.CallOption) (schedulerv1.Scheduler_ReportPieceResultClient, error) {
return &dummyPeerPacketStream{}, nil
}
func (d *dummySchedulerClient) ReportPeerResult(ctx context.Context, result *scheduler.PeerResult, option ...grpc.CallOption) error {
func (d *dummySchedulerClient) ReportPeerResult(ctx context.Context, result *schedulerv1.PeerResult, option ...grpc.CallOption) error {
return nil
}
func (d *dummySchedulerClient) LeaveTask(ctx context.Context, target *scheduler.PeerTarget, option ...grpc.CallOption) error {
func (d *dummySchedulerClient) LeaveTask(ctx context.Context, target *schedulerv1.PeerTarget, option ...grpc.CallOption) error {
return nil
}
func (d *dummySchedulerClient) StatTask(ctx context.Context, request *scheduler.StatTaskRequest, option ...grpc.CallOption) (*scheduler.Task, error) {
func (d *dummySchedulerClient) StatTask(ctx context.Context, request *schedulerv1.StatTaskRequest, option ...grpc.CallOption) (*schedulerv1.Task, error) {
panic("should not call this function")
}
func (d *dummySchedulerClient) AnnounceTask(ctx context.Context, request *scheduler.AnnounceTaskRequest, option ...grpc.CallOption) error {
func (d *dummySchedulerClient) AnnounceTask(ctx context.Context, request *schedulerv1.AnnounceTaskRequest, option ...grpc.CallOption) error {
panic("should not call this function")
}
@ -70,12 +71,12 @@ type dummyPeerPacketStream struct {
grpc.ClientStream
}
func (d *dummyPeerPacketStream) Recv() (*scheduler.PeerPacket, error) {
// TODO set base.Code_SchedNeedBackSource in *scheduler.PeerPacket instead of error
return nil, dferrors.New(base.Code_SchedNeedBackSource, "")
func (d *dummyPeerPacketStream) Recv() (*schedulerv1.PeerPacket, error) {
// TODO set commonv1.Code_SchedNeedBackSource in *scheduler.PeerPacket instead of error
return nil, dferrors.New(commonv1.Code_SchedNeedBackSource, "")
}
func (d *dummyPeerPacketStream) Send(pr *scheduler.PieceResult) error {
func (d *dummyPeerPacketStream) Send(pr *schedulerv1.PieceResult) error {
return nil
}

17
client/daemon/peer/peertask_file.go
View File

@ -23,18 +23,19 @@ import (
"go.opentelemetry.io/otel/trace"
"golang.org/x/time/rate"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type FileTaskRequest struct {
scheduler.PeerTaskRequest
schedulerv1.PeerTaskRequest
Output string
Limit float64
DisableBackSource bool
@ -68,7 +69,7 @@ type fileTask struct {
type ProgressState struct {
Success bool
Code base.Code
Code commonv1.Code
Msg string
}
@ -142,7 +143,7 @@ func (f *fileTask) syncProgress() {
pg := &FileTaskProgress{
State: &ProgressState{
Success: true,
Code: base.Code_Success,
Code: commonv1.Code_Success,
Msg: "downloading",
},
TaskID: f.peerTaskConductor.GetTaskID(),
@ -178,7 +179,7 @@ func (f *fileTask) storeToOutput() {
OriginalOffset: f.request.KeepOriginalOffset,
})
if err != nil {
f.sendFailProgress(base.Code_ClientError, err.Error())
f.sendFailProgress(commonv1.Code_ClientError, err.Error())
return
}
f.sendSuccessProgress()
@ -189,7 +190,7 @@ func (f *fileTask) sendSuccessProgress() {
pg := &FileTaskProgress{
State: &ProgressState{
Success: true,
Code: base.Code_Success,
Code: commonv1.Code_Success,
Msg: "done",
},
TaskID: f.peerTaskConductor.GetTaskID(),
@ -223,7 +224,7 @@ func (f *fileTask) sendSuccessProgress() {
}
}
func (f *fileTask) sendFailProgress(code base.Code, msg string) {
func (f *fileTask) sendFailProgress(code commonv1.Code, msg string) {
var progressDone bool
pg := &FileTaskProgress{
State: &ProgressState{

41
client/daemon/peer/peertask_manager.go
View File

@ -32,14 +32,15 @@ import (
"golang.org/x/time/rate"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
schedulerclient "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client"
)
@ -57,15 +58,15 @@ type TaskManager interface {
StartSeedTask(ctx context.Context, req *SeedTaskRequest) (
seedTaskResult *SeedTaskResponse, reuse bool, err error)
Subscribe(request *base.PieceTaskRequest) (*SubscribeResponse, bool)
Subscribe(request *commonv1.PieceTaskRequest) (*SubscribeResponse, bool)
IsPeerTaskRunning(taskID string) (Task, bool)
// StatTask checks whether the given task exists in P2P network
StatTask(ctx context.Context, taskID string) (*scheduler.Task, error)
StatTask(ctx context.Context, taskID string) (*schedulerv1.Task, error)
// AnnouncePeerTask announces peer task info to P2P network
AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType base.TaskType, urlMeta *base.UrlMeta) error
AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType commonv1.TaskType, urlMeta *commonv1.UrlMeta) error
GetPieceManager() PieceManager
@ -119,7 +120,7 @@ func init() {
}
type peerTaskManager struct {
host *scheduler.PeerHost
host *schedulerv1.PeerHost
schedulerClient schedulerclient.Client
schedulerOption config.SchedulerOption
pieceManager PieceManager
@ -143,7 +144,7 @@ type peerTaskManager struct {
}
func NewPeerTaskManager(
host *scheduler.PeerHost,
host *schedulerv1.PeerHost,
pieceManager PieceManager,
storageManager storage.Manager,
schedulerClient schedulerclient.Client,
@ -183,7 +184,7 @@ func (ptm *peerTaskManager) findPeerTaskConductor(taskID string) (*peerTaskCondu
func (ptm *peerTaskManager) getPeerTaskConductor(ctx context.Context,
taskID string,
request *scheduler.PeerTaskRequest,
request *schedulerv1.PeerTaskRequest,
limit rate.Limit,
parent *peerTaskConductor,
rg *util.Range,
@ -206,7 +207,7 @@ func (ptm *peerTaskManager) getPeerTaskConductor(ctx context.Context,
func (ptm *peerTaskManager) getOrCreatePeerTaskConductor(
ctx context.Context,
taskID string,
request *scheduler.PeerTaskRequest,
request *schedulerv1.PeerTaskRequest,
limit rate.Limit,
parent *peerTaskConductor,
rg *util.Range,
@ -238,7 +239,7 @@ func (ptm *peerTaskManager) getOrCreatePeerTaskConductor(
err := ptc.initStorage(desiredLocation)
if err != nil {
ptc.Errorf("init storage error: %s", err)
ptc.cancel(base.Code_ClientError, err.Error())
ptc.cancel(commonv1.Code_ClientError, err.Error())
return nil, false, err
}
return ptc, true, nil
@ -248,15 +249,15 @@ func (ptm *peerTaskManager) enabledPrefetch(rg *util.Range) bool {
return ptm.enablePrefetch && rg != nil
}
func (ptm *peerTaskManager) prefetchParentTask(request *scheduler.PeerTaskRequest, desiredLocation string) *peerTaskConductor {
req := &scheduler.PeerTaskRequest{
func (ptm *peerTaskManager) prefetchParentTask(request *schedulerv1.PeerTaskRequest, desiredLocation string) *peerTaskConductor {
req := &schedulerv1.PeerTaskRequest{
Url: request.Url,
PeerId: request.PeerId,
PeerHost: ptm.host,
HostLoad: request.HostLoad,
IsMigrating: request.IsMigrating,
Pattern: request.Pattern,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: request.UrlMeta.Digest,
Tag: request.UrlMeta.Tag,
Filter: request.UrlMeta.Filter,
@ -320,7 +321,7 @@ func (ptm *peerTaskManager) StartFileTask(ctx context.Context, req *FileTaskRequ
}
func (ptm *peerTaskManager) StartStreamTask(ctx context.Context, req *StreamTaskRequest) (io.ReadCloser, map[string]string, error) {
peerTaskRequest := &scheduler.PeerTaskRequest{
peerTaskRequest := &schedulerv1.PeerTaskRequest{
Url: req.URL,
UrlMeta: req.URLMeta,
PeerId: req.PeerID,
@ -379,7 +380,7 @@ type SubscribeResponse struct {
FailReason func() error
}
func (ptm *peerTaskManager) Subscribe(request *base.PieceTaskRequest) (*SubscribeResponse, bool) {
func (ptm *peerTaskManager) Subscribe(request *commonv1.PieceTaskRequest) (*SubscribeResponse, bool) {
ptc, ok := ptm.findPeerTaskConductor(request.TaskId)
if !ok {
return nil, false
@ -413,8 +414,8 @@ func (ptm *peerTaskManager) IsPeerTaskRunning(taskID string) (Task, bool) {
return nil, ok
}
func (ptm *peerTaskManager) StatTask(ctx context.Context, taskID string) (*scheduler.Task, error) {
req := &scheduler.StatTaskRequest{
func (ptm *peerTaskManager) StatTask(ctx context.Context, taskID string) (*schedulerv1.Task, error) {
req := &schedulerv1.StatTaskRequest{
TaskId: taskID,
}
@ -425,7 +426,7 @@ func (ptm *peerTaskManager) GetPieceManager() PieceManager {
return ptm.pieceManager
}
func (ptm *peerTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType base.TaskType, urlMeta *base.UrlMeta) error {
func (ptm *peerTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType commonv1.TaskType, urlMeta *commonv1.UrlMeta) error {
// Check if the given task is completed in local storageManager.
if ptm.storageManager.FindCompletedTask(meta.TaskID) == nil {
return errors.New("task not found in local storage")
@ -437,7 +438,7 @@ func (ptm *peerTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.P
return err
}
piecePacket, err := ptm.storageManager.GetPieces(ctx, &base.PieceTaskRequest{
piecePacket, err := ptm.storageManager.GetPieces(ctx, &commonv1.PieceTaskRequest{
TaskId: meta.TaskID,
DstPid: meta.PeerID,
StartNum: 0,
@ -449,7 +450,7 @@ func (ptm *peerTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.P
piecePacket.DstAddr = fmt.Sprintf("%s:%d", ptm.host.Ip, ptm.host.DownPort)
// Announce peer task to scheduler
if err := ptm.schedulerClient.AnnounceTask(ctx, &scheduler.AnnounceTaskRequest{
if err := ptm.schedulerClient.AnnounceTask(ctx, &schedulerv1.AnnounceTaskRequest{
TaskId: meta.TaskID,
TaskType: taskType,
Url: url,

12
client/daemon/peer/peertask_manager_mock.go
View File

@ -9,10 +9,10 @@ import (
io "io"
reflect "reflect"
v1 "d7y.io/api/pkg/apis/common/v1"
v10 "d7y.io/api/pkg/apis/scheduler/v1"
storage "d7y.io/dragonfly/v2/client/daemon/storage"
dflog "d7y.io/dragonfly/v2/internal/dflog"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
scheduler "d7y.io/dragonfly/v2/pkg/rpc/scheduler"
gomock "github.com/golang/mock/gomock"
status "google.golang.org/grpc/status"
)
@ -41,7 +41,7 @@ func (m *MockTaskManager) EXPECT() *MockTaskManagerMockRecorder {
}
// AnnouncePeerTask mocks base method.
func (m *MockTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType base.TaskType, urlMeta *base.UrlMeta) error {
func (m *MockTaskManager) AnnouncePeerTask(ctx context.Context, meta storage.PeerTaskMetadata, url string, taskType v1.TaskType, urlMeta *v1.UrlMeta) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AnnouncePeerTask", ctx, meta, url, taskType, urlMeta)
ret0, _ := ret[0].(error)
@ -132,10 +132,10 @@ func (mr *MockTaskManagerMockRecorder) StartStreamTask(ctx, req interface{}) *go
}
// StatTask mocks base method.
func (m *MockTaskManager) StatTask(ctx context.Context, taskID string) (*scheduler.Task, error) {
func (m *MockTaskManager) StatTask(ctx context.Context, taskID string) (*v10.Task, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatTask", ctx, taskID)
ret0, _ := ret[0].(*scheduler.Task)
ret0, _ := ret[0].(*v10.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -161,7 +161,7 @@ func (mr *MockTaskManagerMockRecorder) Stop(ctx interface{}) *gomock.Call {
}
// Subscribe mocks base method.
func (m *MockTaskManager) Subscribe(request *base.PieceTaskRequest) (*SubscribeResponse, bool) {
func (m *MockTaskManager) Subscribe(request *v1.PieceTaskRequest) (*SubscribeResponse, bool) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Subscribe", request)
ret0, _ := ret[0].(*SubscribeResponse)

133
client/daemon/peer/peertask_manager_test.go
View File

@ -42,6 +42,11 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
schedulerv1mocks "d7y.io/api/pkg/apis/scheduler/v1/mocks"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/test"
@ -52,14 +57,10 @@ import (
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
daemonserver "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
servermocks "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server/mocks"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
schedulerclient "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client"
mock_scheduler_client "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client/mocks"
mock_scheduler "d7y.io/dragonfly/v2/pkg/rpc/scheduler/mocks"
schedulerclientmocks "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client/mocks"
"d7y.io/dragonfly/v2/pkg/source"
"d7y.io/dragonfly/v2/pkg/source/clients/httpprotocol"
sourcemocks "d7y.io/dragonfly/v2/pkg/source/mocks"
@ -79,7 +80,7 @@ type componentsOption struct {
sourceClient source.ResourceClient
peerPacketDelay []time.Duration
backSource bool
scope base.SizeScope
scope commonv1.SizeScope
content []byte
getPieceTasks bool
}
@ -97,8 +98,8 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
pieces[i] = digest.MD5FromReader(io.LimitReader(r, int64(opt.pieceSize)))
}
totalDigests := digest.SHA256FromStrings(pieces...)
genPiecePacket := func(request *base.PieceTaskRequest) *base.PiecePacket {
var tasks []*base.PieceInfo
genPiecePacket := func(request *commonv1.PieceTaskRequest) *commonv1.PiecePacket {
var tasks []*commonv1.PieceInfo
for i := uint32(0); i < request.Limit; i++ {
start := opt.pieceSize * (request.StartNum + i)
if int64(start)+1 > opt.contentLength {
@ -109,7 +110,7 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
size = uint32(opt.contentLength) - start
}
tasks = append(tasks,
&base.PieceInfo{
&commonv1.PieceInfo{
PieceNum: int32(request.StartNum + i),
RangeStart: uint64(start),
RangeSize: size,
@ -118,7 +119,7 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
PieceStyle: 0,
})
}
return &base.PiecePacket{
return &commonv1.PiecePacket{
TaskId: request.TaskId,
DstPid: "peer-x",
PieceInfos: tasks,
@ -129,18 +130,18 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
}
if opt.getPieceTasks {
daemon.EXPECT().GetPieceTasks(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
DoAndReturn(func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
return genPiecePacket(request), nil
})
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(arg0 dfdaemon.Daemon_SyncPieceTasksServer) error {
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(arg0 dfdaemonv1.Daemon_SyncPieceTasksServer) error {
return status.Error(codes.Unimplemented, "TODO")
})
} else {
daemon.EXPECT().GetPieceTasks(gomock.Any(), gomock.Any()).AnyTimes().
DoAndReturn(func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
DoAndReturn(func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
return nil, status.Error(codes.Unimplemented, "TODO")
})
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(s dfdaemon.Daemon_SyncPieceTasksServer) error {
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(s dfdaemonv1.Daemon_SyncPieceTasksServer) error {
request, err := s.Recv()
if err != nil {
return err
@ -177,9 +178,9 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
time.Sleep(100 * time.Millisecond)
// 2. setup a scheduler
pps := mock_scheduler.NewMockScheduler_ReportPieceResultClient(ctrl)
pps := schedulerv1mocks.NewMockScheduler_ReportPieceResultClient(ctrl)
pps.EXPECT().Send(gomock.Any()).AnyTimes().DoAndReturn(
func(pr *scheduler.PieceResult) error {
func(pr *schedulerv1.PieceResult) error {
return nil
})
var (
@ -188,7 +189,7 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
)
sent <- struct{}{}
pps.EXPECT().Recv().AnyTimes().DoAndReturn(
func() (*scheduler.PeerPacket, error) {
func() (*schedulerv1.PeerPacket, error) {
if len(opt.peerPacketDelay) > delayCount {
if delay := opt.peerPacketDelay[delayCount]; delay > 0 {
time.Sleep(delay)
@ -197,14 +198,14 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
}
<-sent
if opt.backSource {
return nil, dferrors.Newf(base.Code_SchedNeedBackSource, "fake back source error")
return nil, dferrors.Newf(commonv1.Code_SchedNeedBackSource, "fake back source error")
}
return &scheduler.PeerPacket{
Code: base.Code_Success,
return &schedulerv1.PeerPacket{
Code: commonv1.Code_Success,
TaskId: opt.taskID,
SrcPid: "127.0.0.1",
ParallelCount: opt.pieceParallelCount,
MainPeer: &scheduler.PeerPacket_DestPeer{
MainPeer: &schedulerv1.PeerPacket_DestPeer{
Ip: "127.0.0.1",
RpcPort: port,
PeerId: "peer-x",
@ -214,27 +215,27 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
})
pps.EXPECT().CloseSend().AnyTimes()
sched := mock_scheduler_client.NewMockClient(ctrl)
sched := schedulerclientmocks.NewMockClient(ctrl)
sched.EXPECT().RegisterPeerTask(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, ptr *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (*scheduler.RegisterResult, error) {
func(ctx context.Context, ptr *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (*schedulerv1.RegisterResult, error) {
switch opt.scope {
case base.SizeScope_TINY:
return &scheduler.RegisterResult{
case commonv1.SizeScope_TINY:
return &schedulerv1.RegisterResult{
TaskId: opt.taskID,
SizeScope: base.SizeScope_TINY,
DirectPiece: &scheduler.RegisterResult_PieceContent{
SizeScope: commonv1.SizeScope_TINY,
DirectPiece: &schedulerv1.RegisterResult_PieceContent{
PieceContent: opt.content,
},
}, nil
case base.SizeScope_SMALL:
return &scheduler.RegisterResult{
case commonv1.SizeScope_SMALL:
return &schedulerv1.RegisterResult{
TaskId: opt.taskID,
SizeScope: base.SizeScope_SMALL,
DirectPiece: &scheduler.RegisterResult_SinglePiece{
SinglePiece: &scheduler.SinglePiece{
SizeScope: commonv1.SizeScope_SMALL,
DirectPiece: &schedulerv1.RegisterResult_SinglePiece{
SinglePiece: &schedulerv1.SinglePiece{
DstPid: "fake-pid",
DstAddr: "fake-addr",
PieceInfo: &base.PieceInfo{
PieceInfo: &commonv1.PieceInfo{
PieceNum: 0,
RangeStart: 0,
RangeSize: uint32(opt.contentLength),
@ -246,19 +247,19 @@ func setupPeerTaskManagerComponents(ctrl *gomock.Controller, opt componentsOptio
},
}, nil
}
return &scheduler.RegisterResult{
return &schedulerv1.RegisterResult{
TaskId: opt.taskID,
SizeScope: base.SizeScope_NORMAL,
SizeScope: commonv1.SizeScope_NORMAL,
DirectPiece: nil,
}, nil
})
sched.EXPECT().ReportPieceResult(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, ptr *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (
scheduler.Scheduler_ReportPieceResultClient, error) {
func(ctx context.Context, ptr *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (
schedulerv1.Scheduler_ReportPieceResultClient, error) {
return pps, nil
})
sched.EXPECT().ReportPeerResult(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, pr *scheduler.PeerResult, opts ...grpc.CallOption) error {
func(ctx context.Context, pr *schedulerv1.PeerResult, opts ...grpc.CallOption) error {
return nil
})
tempDir, _ := os.MkdirTemp("", "d7y-test-*")
@ -295,7 +296,7 @@ func setupMockManager(ctrl *gomock.Controller, ts *testSpec, opt componentsOptio
}
ptm := &peerTaskManager{
calculateDigest: true,
host: &scheduler.PeerHost{
host: &schedulerv1.PeerHost{
Ip: "127.0.0.1",
},
conductorLock: &sync.Mutex{},
@ -336,7 +337,7 @@ type testSpec struct {
httpRange *util.Range // only used in back source cases
pieceParallelCount int32
pieceSize int
sizeScope base.SizeScope
sizeScope commonv1.SizeScope
peerID string
url string
legacyFeature bool
@ -386,7 +387,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
pieceSize: 1024,
peerID: "normal-size-peer",
url: "http://localhost/test/data",
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
mockPieceDownloader: commonPieceDownloader,
mockHTTPSourceClient: nil,
},
@ -397,7 +398,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
pieceSize: 16384,
peerID: "small-size-peer",
url: "http://localhost/test/data",
sizeScope: base.SizeScope_SMALL,
sizeScope: commonv1.SizeScope_SMALL,
mockPieceDownloader: commonPieceDownloader,
mockHTTPSourceClient: nil,
},
@ -408,7 +409,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
pieceSize: 1024,
peerID: "tiny-size-peer",
url: "http://localhost/test/data",
sizeScope: base.SizeScope_TINY,
sizeScope: commonv1.SizeScope_TINY,
mockPieceDownloader: nil,
mockHTTPSourceClient: nil,
},
@ -421,7 +422,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
peerID: "normal-size-peer-back-source",
backSource: true,
url: "http://localhost/test/data",
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
mockPieceDownloader: nil,
mockHTTPSourceClient: func(t *testing.T, ctrl *gomock.Controller, rg *util.Range, taskData []byte, url string) source.ResourceClient {
sourceClient := sourcemocks.NewMockResourceClient(ctrl)
@ -445,7 +446,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
peerID: "normal-size-peer-range-back-source",
backSource: true,
url: "http://localhost/test/data",
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
httpRange: &util.Range{
Start: 0,
Length: 4096,
@ -487,7 +488,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
peerID: "normal-size-peer-back-source-no-length",
backSource: true,
url: "http://localhost/test/data",
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
mockPieceDownloader: nil,
mockHTTPSourceClient: func(t *testing.T, ctrl *gomock.Controller, rg *util.Range, taskData []byte, url string) source.ResourceClient {
sourceClient := sourcemocks.NewMockResourceClient(ctrl)
@ -511,7 +512,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
peerID: "normal-size-peer-back-source-aligning-no-length",
backSource: true,
url: "http://localhost/test/data",
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
mockPieceDownloader: nil,
mockHTTPSourceClient: func(t *testing.T, ctrl *gomock.Controller, rg *util.Range, taskData []byte, url string) source.ResourceClient {
sourceClient := sourcemocks.NewMockResourceClient(ctrl)
@ -546,7 +547,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
})
return server.URL
},
sizeScope: base.SizeScope_NORMAL,
sizeScope: commonv1.SizeScope_NORMAL,
mockPieceDownloader: nil,
mockHTTPSourceClient: nil,
},
@ -573,7 +574,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
defer ctrl.Finish()
mockContentLength := len(tc.taskData)
urlMeta := &base.UrlMeta{
urlMeta := &commonv1.UrlMeta{
Tag: "d7y-test",
}
@ -636,7 +637,7 @@ func TestPeerTaskManager_TaskSuite(t *testing.T) {
}
}
func (ts *testSpec) run(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *base.UrlMeta) {
func (ts *testSpec) run(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *commonv1.UrlMeta) {
switch ts.taskType {
case taskTypeFile:
ts.runFileTaskTest(assert, require, mm, urlMeta)
@ -651,7 +652,7 @@ func (ts *testSpec) run(assert *testifyassert.Assertions, require *testifyrequir
}
}
func (ts *testSpec) runFileTaskTest(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *base.UrlMeta) {
func (ts *testSpec) runFileTaskTest(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *commonv1.UrlMeta) {
var output = "../test/testdata/test.output"
defer func() {
assert.Nil(os.Remove(output))
@ -659,11 +660,11 @@ func (ts *testSpec) runFileTaskTest(assert *testifyassert.Assertions, require *t
progress, _, err := mm.peerTaskManager.StartFileTask(
context.Background(),
&FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
Url: ts.url,
UrlMeta: urlMeta,
PeerId: ts.peerID,
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
},
Output: output,
})
@ -685,7 +686,7 @@ func (ts *testSpec) runFileTaskTest(assert *testifyassert.Assertions, require *t
require.Equal(ts.taskData, outputBytes, "output and desired output must match")
}
func (ts *testSpec) runStreamTaskTest(_ *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *base.UrlMeta) {
func (ts *testSpec) runStreamTaskTest(_ *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *commonv1.UrlMeta) {
r, _, err := mm.peerTaskManager.StartStreamTask(
context.Background(),
&StreamTaskRequest{
@ -700,15 +701,15 @@ func (ts *testSpec) runStreamTaskTest(_ *testifyassert.Assertions, require *test
require.Equal(ts.taskData, outputBytes, "output and desired output must match")
}
func (ts *testSpec) runSeedTaskTest(_ *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *base.UrlMeta) {
func (ts *testSpec) runSeedTaskTest(_ *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *commonv1.UrlMeta) {
r, _, err := mm.peerTaskManager.StartSeedTask(
context.Background(),
&SeedTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
Url: ts.url,
UrlMeta: urlMeta,
PeerId: ts.peerID,
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
HostLoad: nil,
IsMigrating: false,
},
@ -746,7 +747,7 @@ loop:
require.True(success, "seed task should success")
}
func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *base.UrlMeta) {
func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *testifyrequire.Assertions, mm *mockManager, urlMeta *commonv1.UrlMeta) {
var (
ptm = mm.peerTaskManager
pieceSize = ts.pieceSize
@ -757,11 +758,11 @@ func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *
assert.Nil(os.Remove(output))
}()
peerTaskRequest := &scheduler.PeerTaskRequest{
peerTaskRequest := &schedulerv1.PeerTaskRequest{
Url: ts.url,
UrlMeta: urlMeta,
PeerId: ts.peerID,
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
}
ptc, created, err := ptm.getOrCreatePeerTaskConductor(
@ -803,11 +804,11 @@ func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *
}
for i := 0; i < ptcCount; i++ {
request := &scheduler.PeerTaskRequest{
request := &schedulerv1.PeerTaskRequest{
Url: ts.url,
UrlMeta: urlMeta,
PeerId: fmt.Sprintf("should-not-use-peer-%d", i),
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
}
p, created, err := ptm.getOrCreatePeerTaskConductor(
context.Background(), taskID, request, rate.Limit(pieceSize*3), nil, nil, "", false)
@ -820,9 +821,9 @@ func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *
require.Nil(ptc.start(), "peerTaskConductor start should be ok")
switch ts.sizeScope {
case base.SizeScope_TINY:
case commonv1.SizeScope_TINY:
require.NotNil(ptc.tinyData)
case base.SizeScope_SMALL:
case commonv1.SizeScope_SMALL:
require.NotNil(ptc.singlePiece)
}
@ -880,11 +881,11 @@ func (ts *testSpec) runConductorTest(assert *testifyassert.Assertions, require *
progress, ok := ptm.tryReuseFilePeerTask(
context.Background(),
&FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
Url: ts.url,
UrlMeta: urlMeta,
PeerId: ts.peerID,
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
},
Output: output,
})

49
client/daemon/peer/peertask_piecetask_poller.go
View File

@ -25,12 +25,13 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/internal/dferrors"
"d7y.io/dragonfly/v2/pkg/retry"
"d7y.io/dragonfly/v2/pkg/rpc/base"
dfclient "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type pieceTaskPoller struct {
@ -39,14 +40,14 @@ type pieceTaskPoller struct {
getPiecesMaxRetry int
}
func (poller *pieceTaskPoller) preparePieceTasks(request *base.PieceTaskRequest) (pp *base.PiecePacket, err error) {
func (poller *pieceTaskPoller) preparePieceTasks(request *commonv1.PieceTaskRequest) (pp *commonv1.PiecePacket, err error) {
ptc := poller.peerTaskConductor
defer ptc.recoverFromPanic()
var retryCount int
prepare:
retryCount++
poller.peerTaskConductor.Debugf("prepare piece tasks, retry count: %d", retryCount)
peerPacket := ptc.peerPacket.Load().(*scheduler.PeerPacket)
peerPacket := ptc.peerPacket.Load().(*schedulerv1.PeerPacket)
if poller.peerTaskConductor.needBackSource.Load() {
return nil, fmt.Errorf("need back source")
@ -74,8 +75,8 @@ prepare:
}
func (poller *pieceTaskPoller) preparePieceTasksByPeer(
curPeerPacket *scheduler.PeerPacket,
peer *scheduler.PeerPacket_DestPeer, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
curPeerPacket *schedulerv1.PeerPacket,
peer *schedulerv1.PeerPacket_DestPeer, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
ptc := poller.peerTaskConductor
if peer == nil {
return nil, fmt.Errorf("empty peer")
@ -89,7 +90,7 @@ func (poller *pieceTaskPoller) preparePieceTasksByPeer(
defer span.End()
var maxRetries = 60
// when cdn returns base.Code_CDNTaskNotFound, report it to scheduler and wait cdn download it.
// when cdn returns commonv1.Code_CDNTaskNotFound, report it to scheduler and wait cdn download it.
retry:
ptc.Debugf("try get piece task from peer %s, piece num: %d, limit: %d\"", peer.PeerId, request.StartNum, request.Limit)
p, err := poller.getPieceTasksByPeer(span, curPeerPacket, peer, request)
@ -115,18 +116,18 @@ retry:
return nil, err
}
}
code := base.Code_ClientPieceRequestFail
code := commonv1.Code_ClientPieceRequestFail
// not grpc error
if de, ok := err.(*dferrors.DfError); ok && uint32(de.Code) > uint32(codes.Unauthenticated) {
ptc.Debugf("get piece task from peer %s with df error, code: %d", peer.PeerId, de.Code)
code = de.Code
}
ptc.Errorf("get piece task from peer %s error: %s, code: %d", peer.PeerId, err, code)
sendError := ptc.sendPieceResult(&scheduler.PieceResult{
sendError := ptc.sendPieceResult(&schedulerv1.PieceResult{
TaskId: ptc.taskID,
SrcPid: ptc.peerID,
DstPid: peer.PeerId,
PieceInfo: &base.PieceInfo{},
PieceInfo: &commonv1.PieceInfo{},
Success: false,
Code: code,
HostLoad: nil,
@ -134,14 +135,14 @@ retry:
})
// error code should be sent to scheduler and the scheduler can schedule a new peer
if sendError != nil {
ptc.cancel(base.Code_SchedError, sendError.Error())
ptc.cancel(commonv1.Code_SchedError, sendError.Error())
span.RecordError(sendError)
ptc.Errorf("send piece result error: %s, code to send: %d", sendError, code)
return nil, sendError
}
// currently, before cdn gc tasks, it did not notify scheduler, when cdn complains Code_CDNTaskNotFound, retry
if maxRetries > 0 && code == base.Code_CDNTaskNotFound && curPeerPacket == ptc.peerPacket.Load().(*scheduler.PeerPacket) {
if maxRetries > 0 && code == commonv1.Code_CDNTaskNotFound && curPeerPacket == ptc.peerPacket.Load().(*schedulerv1.PeerPacket) {
span.AddEvent("retry for CdnTaskNotFound")
time.Sleep(time.Second)
maxRetries--
@ -152,9 +153,9 @@ retry:
func (poller *pieceTaskPoller) getPieceTasksByPeer(
span trace.Span,
curPeerPacket *scheduler.PeerPacket,
peer *scheduler.PeerPacket_DestPeer,
request *base.PieceTaskRequest) (*base.PiecePacket, error) {
curPeerPacket *schedulerv1.PeerPacket,
peer *schedulerv1.PeerPacket_DestPeer,
request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
var (
peerPacketChanged bool
count int
@ -174,7 +175,7 @@ func (poller *pieceTaskPoller) getPieceTasksByPeer(
if de, ok := getError.(*dferrors.DfError); ok {
ptc.Debugf("get piece task with grpc error, code: %d", de.Code)
// bad request, like invalid piece num, just exit
if de.Code == base.Code_BadRequest {
if de.Code == commonv1.Code_BadRequest {
span.AddEvent("bad request")
ptc.Warnf("get piece task from peer %s canceled: %s", peer.PeerId, getError)
return nil, true, getError
@ -182,7 +183,7 @@ func (poller *pieceTaskPoller) getPieceTasksByPeer(
}
// fast way 2 to exit retry
lastPeerPacket := ptc.peerPacket.Load().(*scheduler.PeerPacket)
lastPeerPacket := ptc.peerPacket.Load().(*schedulerv1.PeerPacket)
if curPeerPacket.CandidatePeers[0].PeerId != lastPeerPacket.CandidatePeers[0].PeerId {
ptc.Warnf("get piece tasks with error: %s, but peer packet changed, switch to new peer packet, current destPeer %s, new destPeer %s", getError,
curPeerPacket.CandidatePeers[0].PeerId, lastPeerPacket.CandidatePeers[0].PeerId)
@ -206,24 +207,24 @@ func (poller *pieceTaskPoller) getPieceTasksByPeer(
}
// by santong: when peer return empty, retry later
sendError := ptc.sendPieceResult(&scheduler.PieceResult{
sendError := ptc.sendPieceResult(&schedulerv1.PieceResult{
TaskId: ptc.taskID,
SrcPid: ptc.peerID,
DstPid: peer.PeerId,
PieceInfo: &base.PieceInfo{},
PieceInfo: &commonv1.PieceInfo{},
Success: false,
Code: base.Code_ClientWaitPieceReady,
Code: commonv1.Code_ClientWaitPieceReady,
HostLoad: nil,
FinishedCount: ptc.readyPieces.Settled(),
})
if sendError != nil {
ptc.cancel(base.Code_ClientPieceRequestFail, sendError.Error())
ptc.cancel(commonv1.Code_ClientPieceRequestFail, sendError.Error())
span.RecordError(sendError)
ptc.Errorf("send piece result with base.Code_ClientWaitPieceReady error: %s", sendError)
ptc.Errorf("send piece result with commonv1.Code_ClientWaitPieceReady error: %s", sendError)
return nil, true, sendError
}
// fast way to exit retry
lastPeerPacket := ptc.peerPacket.Load().(*scheduler.PeerPacket)
lastPeerPacket := ptc.peerPacket.Load().(*schedulerv1.PeerPacket)
if curPeerPacket.CandidatePeers[0].PeerId != lastPeerPacket.CandidatePeers[0].PeerId {
ptc.Warnf("get empty pieces and peer packet changed, switch to new peer packet, current destPeer %s, new destPeer %s",
curPeerPacket.CandidatePeers[0].PeerId, lastPeerPacket.CandidatePeers[0].PeerId)
@ -241,7 +242,7 @@ func (poller *pieceTaskPoller) getPieceTasksByPeer(
}
if err == nil {
return p.(*base.PiecePacket), nil
return p.(*commonv1.PiecePacket), nil
}
return nil, err
}

57
client/daemon/peer/peertask_piecetask_synchronizer.go
View File

@ -29,12 +29,13 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
dfclient "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type pieceTaskSyncManager struct {
@ -50,8 +51,8 @@ type pieceTaskSyncManager struct {
type pieceTaskSynchronizer struct {
*logger.SugaredLoggerOnWith
span trace.Span
client dfdaemon.Daemon_SyncPieceTasksClient
dstPeer *scheduler.PeerPacket_DestPeer
client dfdaemonv1.Daemon_SyncPieceTasksClient
dstPeer *schedulerv1.PeerPacket_DestPeer
error atomic.Value
peerTaskConductor *peerTaskConductor
pieceRequestCh chan *DownloadPieceRequest
@ -59,7 +60,7 @@ type pieceTaskSynchronizer struct {
type synchronizerWatchdog struct {
done chan struct{}
mainPeer atomic.Value // save *scheduler.PeerPacket_DestPeer
mainPeer atomic.Value // save *schedulerv1.PeerPacket_DestPeer
syncSuccess *atomic.Bool
peerTaskConductor *peerTaskConductor
}
@ -69,7 +70,7 @@ type pieceTaskSynchronizerError struct {
}
// FIXME for compatibility, sync will be called after the dfclient.GetPieceTasks deprecated and the pieceTaskPoller removed
func (s *pieceTaskSyncManager) sync(pp *scheduler.PeerPacket, desiredPiece int32) error {
func (s *pieceTaskSyncManager) sync(pp *schedulerv1.PeerPacket, desiredPiece int32) error {
var (
peers = map[string]bool{}
errs []error
@ -116,7 +117,7 @@ func (s *pieceTaskSyncManager) sync(pp *scheduler.PeerPacket, desiredPiece int32
return nil
}
func (s *pieceTaskSyncManager) cleanStaleWorker(destPeers []*scheduler.PeerPacket_DestPeer) {
func (s *pieceTaskSyncManager) cleanStaleWorker(destPeers []*schedulerv1.PeerPacket_DestPeer) {
var (
peers = map[string]bool{}
)
@ -141,9 +142,9 @@ func (s *pieceTaskSyncManager) cleanStaleWorker(destPeers []*scheduler.PeerPacke
func (s *pieceTaskSyncManager) newPieceTaskSynchronizer(
ctx context.Context,
dstPeer *scheduler.PeerPacket_DestPeer,
dstPeer *schedulerv1.PeerPacket_DestPeer,
desiredPiece int32) error {
request := &base.PieceTaskRequest{
request := &commonv1.PieceTaskRequest{
TaskId: s.peerTaskConductor.taskID,
SrcPid: s.peerTaskConductor.peerID,
DstPid: dstPeer.PeerId,
@ -197,8 +198,8 @@ func (s *pieceTaskSyncManager) newPieceTaskSynchronizer(
}
func (s *pieceTaskSyncManager) newMultiPieceTaskSynchronizer(
destPeers []*scheduler.PeerPacket_DestPeer,
desiredPiece int32) (legacyPeers []*scheduler.PeerPacket_DestPeer) {
destPeers []*schedulerv1.PeerPacket_DestPeer,
desiredPiece int32) (legacyPeers []*schedulerv1.PeerPacket_DestPeer) {
s.Lock()
defer func() {
if s.peerTaskConductor.ptm.watchdogTimeout > 0 {
@ -225,11 +226,11 @@ func (s *pieceTaskSyncManager) newMultiPieceTaskSynchronizer(
// other errors, report to scheduler
if errors.Is(err, context.DeadlineExceeded) {
// connect timeout error, report to scheduler to get more available peers
s.reportInvalidPeer(peer, base.Code_ClientConnectionError)
s.reportInvalidPeer(peer, commonv1.Code_ClientConnectionError)
s.peerTaskConductor.Infof("connect to peer %s with error: %s, peer is invalid, skip legacy grpc", peer.PeerId, err)
} else {
// other errors, report to scheduler to get more available peers
s.reportInvalidPeer(peer, base.Code_ClientPieceRequestFail)
s.reportInvalidPeer(peer, commonv1.Code_ClientPieceRequestFail)
s.peerTaskConductor.Errorf("connect peer %s error: %s, not codes.Unimplemented", peer.PeerId, err)
}
}
@ -237,7 +238,7 @@ func (s *pieceTaskSyncManager) newMultiPieceTaskSynchronizer(
return legacyPeers
}
func (s *pieceTaskSyncManager) resetWatchdog(mainPeer *scheduler.PeerPacket_DestPeer) {
func (s *pieceTaskSyncManager) resetWatchdog(mainPeer *schedulerv1.PeerPacket_DestPeer) {
if s.watchdog != nil {
close(s.watchdog.done)
s.peerTaskConductor.Debugf("close old watchdog")
@ -253,12 +254,12 @@ func (s *pieceTaskSyncManager) resetWatchdog(mainPeer *scheduler.PeerPacket_Dest
go s.watchdog.watch(s.peerTaskConductor.ptm.watchdogTimeout)
}
func compositePieceResult(peerTaskConductor *peerTaskConductor, destPeer *scheduler.PeerPacket_DestPeer, code base.Code) *scheduler.PieceResult {
return &scheduler.PieceResult{
func compositePieceResult(peerTaskConductor *peerTaskConductor, destPeer *schedulerv1.PeerPacket_DestPeer, code commonv1.Code) *schedulerv1.PieceResult {
return &schedulerv1.PieceResult{
TaskId: peerTaskConductor.taskID,
SrcPid: peerTaskConductor.peerID,
DstPid: destPeer.PeerId,
PieceInfo: &base.PieceInfo{},
PieceInfo: &commonv1.PieceInfo{},
Success: false,
Code: code,
HostLoad: nil,
@ -266,18 +267,18 @@ func compositePieceResult(peerTaskConductor *peerTaskConductor, destPeer *schedu
}
}
func (s *pieceTaskSyncManager) reportInvalidPeer(destPeer *scheduler.PeerPacket_DestPeer, code base.Code) {
func (s *pieceTaskSyncManager) reportInvalidPeer(destPeer *schedulerv1.PeerPacket_DestPeer, code commonv1.Code) {
sendError := s.peerTaskConductor.sendPieceResult(compositePieceResult(s.peerTaskConductor, destPeer, code))
if sendError != nil {
s.peerTaskConductor.Errorf("connect peer %s failed and send piece result with error: %s", destPeer.PeerId, sendError)
go s.peerTaskConductor.cancel(base.Code_SchedError, sendError.Error())
go s.peerTaskConductor.cancel(commonv1.Code_SchedError, sendError.Error())
} else {
s.peerTaskConductor.Debugf("report invalid peer %s/%d to scheduler", destPeer.PeerId, code)
}
}
// acquire send the target piece to other peers
func (s *pieceTaskSyncManager) acquire(request *base.PieceTaskRequest) (attempt int, success int) {
func (s *pieceTaskSyncManager) acquire(request *commonv1.PieceTaskRequest) (attempt int, success int) {
s.RLock()
for _, p := range s.workers {
attempt++
@ -308,7 +309,7 @@ func (s *pieceTaskSynchronizer) close() {
s.span.End()
}
func (s *pieceTaskSynchronizer) dispatchPieceRequest(piecePacket *base.PiecePacket) {
func (s *pieceTaskSynchronizer) dispatchPieceRequest(piecePacket *commonv1.PiecePacket) {
s.peerTaskConductor.updateMetadata(piecePacket)
pieceCount := len(piecePacket.PieceInfos)
@ -350,7 +351,7 @@ func (s *pieceTaskSynchronizer) dispatchPieceRequest(piecePacket *base.PiecePack
}
}
func (s *pieceTaskSynchronizer) receive(piecePacket *base.PiecePacket) {
func (s *pieceTaskSynchronizer) receive(piecePacket *commonv1.PiecePacket) {
var err error
for {
s.dispatchPieceRequest(piecePacket)
@ -373,7 +374,7 @@ func (s *pieceTaskSynchronizer) receive(piecePacket *base.PiecePacket) {
}
}
func (s *pieceTaskSynchronizer) acquire(request *base.PieceTaskRequest) error {
func (s *pieceTaskSynchronizer) acquire(request *commonv1.PieceTaskRequest) error {
if s.error.Load() != nil {
err := s.error.Load().(*pieceTaskSynchronizerError).err
s.Debugf("synchronizer already error %s, skip acquire more pieces", err)
@ -393,10 +394,10 @@ func (s *pieceTaskSynchronizer) acquire(request *base.PieceTaskRequest) error {
func (s *pieceTaskSynchronizer) reportError(err error) {
s.span.RecordError(err)
sendError := s.peerTaskConductor.sendPieceResult(compositePieceResult(s.peerTaskConductor, s.dstPeer, base.Code_ClientPieceRequestFail))
sendError := s.peerTaskConductor.sendPieceResult(compositePieceResult(s.peerTaskConductor, s.dstPeer, commonv1.Code_ClientPieceRequestFail))
if sendError != nil {
s.Errorf("sync piece info failed and send piece result with error: %s", sendError)
go s.peerTaskConductor.cancel(base.Code_SchedError, sendError.Error())
go s.peerTaskConductor.cancel(commonv1.Code_SchedError, sendError.Error())
} else {
s.Debugf("report sync piece error to scheduler")
}
@ -438,10 +439,10 @@ func (s *synchronizerWatchdog) watch(timeout time.Duration) {
func (s *synchronizerWatchdog) reportWatchFailed() {
sendError := s.peerTaskConductor.sendPieceResult(compositePieceResult(
s.peerTaskConductor, s.mainPeer.Load().(*scheduler.PeerPacket_DestPeer), base.Code_ClientPieceRequestFail))
s.peerTaskConductor, s.mainPeer.Load().(*schedulerv1.PeerPacket_DestPeer), commonv1.Code_ClientPieceRequestFail))
if sendError != nil {
s.peerTaskConductor.Errorf("watchdog sync piece info failed and send piece result with error: %s", sendError)
go s.peerTaskConductor.cancel(base.Code_SchedError, sendError.Error())
go s.peerTaskConductor.cancel(commonv1.Code_SchedError, sendError.Error())
} else {
s.peerTaskConductor.Debugf("report watchdog sync piece error to scheduler")
}

9
client/daemon/peer/peertask_piecetask_synchronizer_test.go
View File

@ -25,9 +25,10 @@ import (
testifyassert "github.com/stretchr/testify/assert"
"go.uber.org/atomic"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/api/pkg/apis/scheduler/v1/mocks"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler/mocks"
)
func Test_watchdog(t *testing.T) {
@ -53,7 +54,7 @@ func Test_watchdog(t *testing.T) {
for _, tt := range testCases {
t.Run(tt.name, func(t *testing.T) {
peer := &scheduler.PeerPacket_DestPeer{}
peer := &schedulerv1.PeerPacket_DestPeer{}
pps := mocks.NewMockScheduler_ReportPieceResultClient(ctrl)
watchdog := &synchronizerWatchdog{
done: make(chan struct{}),
@ -71,7 +72,7 @@ func Test_watchdog(t *testing.T) {
if tt.ok {
watchdog.peerTaskConductor.readyPieces.Set(0)
} else {
pps.EXPECT().Send(gomock.Any()).DoAndReturn(func(pr *scheduler.PieceResult) error {
pps.EXPECT().Send(gomock.Any()).DoAndReturn(func(pr *schedulerv1.PieceResult) error {
assert.Equal(peer.PeerId, pr.DstPid)
return nil
})

5
client/daemon/peer/peertask_reuse.go
View File

@ -27,12 +27,13 @@ import (
semconv "go.opentelemetry.io/otel/semconv/v1.7.0"
"go.opentelemetry.io/otel/trace"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
var _ *logger.SugaredLoggerOnWith // pin this package for no log code generation
@ -141,7 +142,7 @@ func (ptm *peerTaskManager) tryReuseFilePeerTask(ctx context.Context,
pg := &FileTaskProgress{
State: &ProgressState{
Success: true,
Code: base.Code_Success,
Code: commonv1.Code_Success,
Msg: "Success",
},
TaskID: taskID,

67
client/daemon/peer/peertask_reuse_test.go
View File

@ -29,12 +29,13 @@ import (
"github.com/golang/mock/gomock"
testifyassert "github.com/stretchr/testify/assert"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/storage/mocks"
"d7y.io/dragonfly/v2/client/daemon/test"
"d7y.io/dragonfly/v2/client/util"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
func TestReuseFilePeerTask(t *testing.T) {
@ -56,10 +57,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "normal completed task found",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -100,10 +101,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "normal completed task not found",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -137,10 +138,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "normal completed subtask found",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -181,10 +182,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "normal completed subtask not found",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -214,10 +215,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "partial task found",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -263,10 +264,10 @@ func TestReuseFilePeerTask(t *testing.T) {
{
name: "partial task found - out of range",
request: &FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
PeerId: "",
Url: "http://example.com/1",
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -317,7 +318,7 @@ func TestReuseFilePeerTask(t *testing.T) {
sm := mocks.NewMockManager(ctrl)
tc.storageManager(sm)
ptm := &peerTaskManager{
host: &scheduler.PeerHost{},
host: &schedulerv1.PeerHost{},
enablePrefetch: tc.enablePrefetch,
storageManager: sm,
}
@ -344,7 +345,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "normal completed task found",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -376,8 +377,8 @@ func TestReuseStreamPeerTask(t *testing.T) {
})
sm.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -397,7 +398,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "normal completed task not found",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -432,7 +433,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "normal completed subtask found",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -464,8 +465,8 @@ func TestReuseStreamPeerTask(t *testing.T) {
})
sm.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -484,7 +485,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "normal completed subtask not found",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -515,7 +516,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "partial task found",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -551,8 +552,8 @@ func TestReuseStreamPeerTask(t *testing.T) {
})
sm.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -571,7 +572,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "partial task found - 2",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -607,8 +608,8 @@ func TestReuseStreamPeerTask(t *testing.T) {
})
sm.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -631,7 +632,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
name: "partial task found - out of range",
request: &StreamTaskRequest{
URL: "http://example.com/1",
URLMeta: &base.UrlMeta{
URLMeta: &commonv1.UrlMeta{
Digest: "",
Tag: "",
Range: "",
@ -667,8 +668,8 @@ func TestReuseStreamPeerTask(t *testing.T) {
})
sm.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -694,7 +695,7 @@ func TestReuseStreamPeerTask(t *testing.T) {
sm := mocks.NewMockManager(ctrl)
tc.storageManager(sm)
ptm := &peerTaskManager{
host: &scheduler.PeerHost{},
host: &schedulerv1.PeerHost{},
enablePrefetch: tc.enablePrefetch,
storageManager: sm,
}

5
client/daemon/peer/peertask_seed.go
View File

@ -22,14 +22,15 @@ import (
"go.opentelemetry.io/otel/trace"
"golang.org/x/time/rate"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/util"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type SeedTaskRequest struct {
scheduler.PeerTaskRequest
schedulerv1.PeerTaskRequest
Limit float64
Callsystem string
Range *util.Range

11
client/daemon/peer/peertask_stream.go
View File

@ -25,27 +25,28 @@ import (
"go.opentelemetry.io/otel/trace"
"golang.org/x/time/rate"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type StreamTaskRequest struct {
// universal resource locator for different kind of storage
URL string
// url meta info
URLMeta *base.UrlMeta
URLMeta *commonv1.UrlMeta
// http range
Range *util.Range
// peer's id and must be global uniqueness
PeerID string
// Pattern to register to scheduler
Pattern base.Pattern
Pattern commonv1.Pattern
}
// StreamTask represents a peer task with stream io for reading directly without once more disk io
@ -66,7 +67,7 @@ type streamTask struct {
func (ptm *peerTaskManager) newStreamTask(
ctx context.Context,
request *scheduler.PeerTaskRequest,
request *schedulerv1.PeerTaskRequest,
rg *util.Range) (*streamTask, error) {
metrics.StreamTaskCount.Add(1)
var limit = rate.Inf

55
client/daemon/peer/peertask_stream_backsource_partial_test.go
View File

@ -38,6 +38,11 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
schedulerv1mocks "d7y.io/api/pkg/apis/scheduler/v1/mocks"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/test"
@ -46,14 +51,10 @@ import (
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
daemonserver "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
servermocks "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server/mocks"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
schedulerclient "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client"
mock_scheduler_client "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client/mocks"
mock_scheduler "d7y.io/dragonfly/v2/pkg/rpc/scheduler/mocks"
clientmocks "d7y.io/dragonfly/v2/pkg/rpc/scheduler/client/mocks"
"d7y.io/dragonfly/v2/pkg/source"
"d7y.io/dragonfly/v2/pkg/source/clients/httpprotocol"
sourcemocks "d7y.io/dragonfly/v2/pkg/source/mocks"
@ -74,12 +75,12 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
piecesMd5 = append(piecesMd5, digest.MD5FromBytes(testBytes[int(i)*int(opt.pieceSize):int(i+1)*int(opt.pieceSize)]))
}
}
daemon.EXPECT().GetPieceTasks(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
var tasks []*base.PieceInfo
daemon.EXPECT().GetPieceTasks(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
var tasks []*commonv1.PieceInfo
// only return first piece
if request.StartNum == 0 {
tasks = append(tasks,
&base.PieceInfo{
&commonv1.PieceInfo{
PieceNum: int32(request.StartNum),
RangeStart: uint64(0),
RangeSize: opt.pieceSize,
@ -88,7 +89,7 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
PieceStyle: 0,
})
}
return &base.PiecePacket{
return &commonv1.PiecePacket{
PieceMd5Sign: digest.SHA256FromStrings(piecesMd5...),
TaskId: request.TaskId,
DstPid: "peer-x",
@ -97,7 +98,7 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
TotalPiece: pieceCount,
}, nil
})
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(arg0 dfdaemon.Daemon_SyncPieceTasksServer) error {
daemon.EXPECT().SyncPieceTasks(gomock.Any()).AnyTimes().DoAndReturn(func(arg0 dfdaemonv1.Daemon_SyncPieceTasksServer) error {
return status.Error(codes.Unimplemented, "TODO")
})
ln, _ := rpc.Listen(dfnet.NetAddr{
@ -112,7 +113,7 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
time.Sleep(100 * time.Millisecond)
// 2. setup a scheduler
pps := mock_scheduler.NewMockScheduler_ReportPieceResultClient(ctrl)
pps := schedulerv1mocks.NewMockScheduler_ReportPieceResultClient(ctrl)
var (
wg = sync.WaitGroup{}
backSourceSent = atomic.Bool{}
@ -120,7 +121,7 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
wg.Add(1)
pps.EXPECT().Send(gomock.Any()).AnyTimes().DoAndReturn(
func(pr *scheduler.PieceResult) error {
func(pr *schedulerv1.PieceResult) error {
if pr.PieceInfo.PieceNum == 0 && pr.Success {
if !backSourceSent.Load() {
wg.Done()
@ -134,7 +135,7 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
schedPeerPacket bool
)
pps.EXPECT().Recv().AnyTimes().DoAndReturn(
func() (*scheduler.PeerPacket, error) {
func() (*schedulerv1.PeerPacket, error) {
if len(opt.peerPacketDelay) > delayCount {
if delay := opt.peerPacketDelay[delayCount]; delay > 0 {
time.Sleep(delay)
@ -144,15 +145,15 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
if schedPeerPacket {
// send back source after piece 0 is done
wg.Wait()
return nil, dferrors.New(base.Code_SchedNeedBackSource, "")
return nil, dferrors.New(commonv1.Code_SchedNeedBackSource, "")
}
schedPeerPacket = true
return &scheduler.PeerPacket{
Code: base.Code_Success,
return &schedulerv1.PeerPacket{
Code: commonv1.Code_Success,
TaskId: opt.taskID,
SrcPid: "127.0.0.1",
ParallelCount: opt.pieceParallelCount,
MainPeer: &scheduler.PeerPacket_DestPeer{
MainPeer: &schedulerv1.PeerPacket_DestPeer{
Ip: "127.0.0.1",
RpcPort: port,
PeerId: "peer-x",
@ -161,21 +162,21 @@ func setupBackSourcePartialComponents(ctrl *gomock.Controller, testBytes []byte,
}, nil
})
pps.EXPECT().CloseSend().AnyTimes()
sched := mock_scheduler_client.NewMockClient(ctrl)
sched := clientmocks.NewMockClient(ctrl)
sched.EXPECT().RegisterPeerTask(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, ptr *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (*scheduler.RegisterResult, error) {
return &scheduler.RegisterResult{
func(ctx context.Context, ptr *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (*schedulerv1.RegisterResult, error) {
return &schedulerv1.RegisterResult{
TaskId: opt.taskID,
SizeScope: base.SizeScope_NORMAL,
SizeScope: commonv1.SizeScope_NORMAL,
DirectPiece: nil,
}, nil
})
sched.EXPECT().ReportPieceResult(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, ptr *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error) {
func(ctx context.Context, ptr *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (schedulerv1.Scheduler_ReportPieceResultClient, error) {
return pps, nil
})
sched.EXPECT().ReportPeerResult(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, pr *scheduler.PeerResult, opts ...grpc.CallOption) error {
func(ctx context.Context, pr *schedulerv1.PeerResult, opts ...grpc.CallOption) error {
return nil
})
tempDir, _ := os.MkdirTemp("", "d7y-test-*")
@ -250,7 +251,7 @@ func TestStreamPeerTask_BackSource_Partial_WithContentLength(t *testing.T) {
}
ptm := &peerTaskManager{
calculateDigest: true,
host: &scheduler.PeerHost{
host: &schedulerv1.PeerHost{
Ip: "127.0.0.1",
},
conductorLock: &sync.Mutex{},
@ -262,13 +263,13 @@ func TestStreamPeerTask_BackSource_Partial_WithContentLength(t *testing.T) {
ScheduleTimeout: util.Duration{Duration: 10 * time.Minute},
},
}
req := &scheduler.PeerTaskRequest{
req := &schedulerv1.PeerTaskRequest{
Url: url,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: "d7y-test",
},
PeerId: peerID,
PeerHost: &scheduler.PeerHost{},
PeerHost: &schedulerv1.PeerHost{},
}
ctx := context.Background()
pt, err := ptm.newStreamTask(ctx, req, nil)

5
client/daemon/peer/piece_downloader.go
View File

@ -29,15 +29,16 @@ import (
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/daemon/storage"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/source"
)
type DownloadPieceRequest struct {
piece *base.PieceInfo
piece *commonv1.PieceInfo
log *logger.SugaredLoggerOnWith
storage storage.TaskStorageDriver
TaskID string

7
client/daemon/peer/piece_downloader_test.go
View File

@ -34,10 +34,11 @@ import (
testifyassert "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/daemon/test"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/source"
"d7y.io/dragonfly/v2/pkg/source/clients/httpprotocol"
)
@ -138,13 +139,13 @@ func TestPieceDownloader_DownloadPiece(t *testing.T) {
DstPid: "",
DstAddr: addr.Host,
CalcDigest: true,
piece: &base.PieceInfo{
piece: &commonv1.PieceInfo{
PieceNum: 0,
RangeStart: tt.rangeStart,
RangeSize: tt.rangeSize,
PieceMd5: digest,
PieceOffset: tt.rangeStart,
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
},
log: logger.With("test", "test"),
})

35
client/daemon/peer/piece_manager.go
View File

@ -34,6 +34,11 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
errordetailsv1 "d7y.io/api/pkg/apis/errordetails/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/storage"
clientutil "d7y.io/dragonfly/v2/client/util"
@ -41,17 +46,13 @@ import (
"d7y.io/dragonfly/v2/internal/util"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/retry"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
"d7y.io/dragonfly/v2/pkg/rpc/errordetails"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/source"
)
type PieceManager interface {
DownloadSource(ctx context.Context, pt Task, request *scheduler.PeerTaskRequest, parsedRange *clientutil.Range) error
DownloadSource(ctx context.Context, pt Task, request *schedulerv1.PeerTaskRequest, parsedRange *clientutil.Range) error
DownloadPiece(ctx context.Context, request *DownloadPieceRequest) (*DownloadPieceResult, error)
ImportFile(ctx context.Context, ptm storage.PeerTaskMetadata, tsd storage.TaskStorageDriver, req *dfdaemon.ImportTaskRequest) error
ImportFile(ctx context.Context, ptm storage.PeerTaskMetadata, tsd storage.TaskStorageDriver, req *dfdaemonv1.ImportTaskRequest) error
Import(ctx context.Context, ptm storage.PeerTaskMetadata, tsd storage.TaskStorageDriver, contentLength int64, reader io.Reader) error
}
@ -271,9 +272,9 @@ func (pm *pieceManager) processPieceFromSource(pt Task,
return
}
func (pm *pieceManager) DownloadSource(ctx context.Context, pt Task, peerTaskRequest *scheduler.PeerTaskRequest, parsedRange *clientutil.Range) error {
func (pm *pieceManager) DownloadSource(ctx context.Context, pt Task, peerTaskRequest *schedulerv1.PeerTaskRequest, parsedRange *clientutil.Range) error {
if peerTaskRequest.UrlMeta == nil {
peerTaskRequest.UrlMeta = &base.UrlMeta{
peerTaskRequest.UrlMeta = &commonv1.UrlMeta{
Header: map[string]string{},
}
} else if peerTaskRequest.UrlMeta.Header == nil {
@ -362,9 +363,9 @@ singleDownload:
hdr[k] = response.Header.Get(k)
}
}
srcErr := &errordetails.SourceError{
srcErr := &errordetailsv1.SourceError{
Temporary: response.Temporary != nil && response.Temporary(),
Metadata: &base.ExtendAttribute{
Metadata: &commonv1.ExtendAttribute{
Header: hdr,
StatusCode: int32(response.StatusCode),
Status: response.Status,
@ -422,7 +423,7 @@ singleDownload:
return pm.downloadKnownLengthSource(ctx, pt, contentLength, pieceSize, reader, response, peerTaskRequest, parsedRange, metadata, supportConcurrent, targetContentLength)
}
func (pm *pieceManager) downloadKnownLengthSource(ctx context.Context, pt Task, contentLength int64, pieceSize uint32, reader io.Reader, response *source.Response, peerTaskRequest *scheduler.PeerTaskRequest, parsedRange *clientutil.Range, metadata *source.Metadata, supportConcurrent bool, targetContentLength int64) error {
func (pm *pieceManager) downloadKnownLengthSource(ctx context.Context, pt Task, contentLength int64, pieceSize uint32, reader io.Reader, response *source.Response, peerTaskRequest *schedulerv1.PeerTaskRequest, parsedRange *clientutil.Range, metadata *source.Metadata, supportConcurrent bool, targetContentLength int64) error {
log := pt.Log()
maxPieceNum := util.ComputePieceCount(contentLength, pieceSize)
pt.SetContentLength(contentLength)
@ -445,7 +446,7 @@ func (pm *pieceManager) downloadKnownLengthSource(ctx context.Context, pt Task,
request := &DownloadPieceRequest{
TaskID: pt.GetTaskID(),
PeerID: pt.GetPeerID(),
piece: &base.PieceInfo{
piece: &commonv1.PieceInfo{
PieceNum: pieceNum,
RangeStart: offset,
RangeSize: uint32(result.Size),
@ -525,7 +526,7 @@ func (pm *pieceManager) downloadUnknownLengthSource(pt Task, pieceSize uint32, r
request := &DownloadPieceRequest{
TaskID: pt.GetTaskID(),
PeerID: pt.GetPeerID(),
piece: &base.PieceInfo{
piece: &commonv1.PieceInfo{
PieceNum: pieceNum,
RangeStart: offset,
RangeSize: uint32(result.Size),
@ -617,7 +618,7 @@ func (pm *pieceManager) processPieceFromFile(ctx context.Context, ptm storage.Pe
return n, nil
}
func (pm *pieceManager) ImportFile(ctx context.Context, ptm storage.PeerTaskMetadata, tsd storage.TaskStorageDriver, req *dfdaemon.ImportTaskRequest) error {
func (pm *pieceManager) ImportFile(ctx context.Context, ptm storage.PeerTaskMetadata, tsd storage.TaskStorageDriver, req *dfdaemonv1.ImportTaskRequest) error {
log := logger.With("function", "ImportFile", "URL", req.Url, "taskID", ptm.TaskID)
// get file size and compute piece size and piece count
stat, err := os.Stat(req.Path)
@ -747,7 +748,7 @@ func (pm *pieceManager) Import(ctx context.Context, ptm storage.PeerTaskMetadata
return nil
}
func (pm *pieceManager) concurrentDownloadSource(ctx context.Context, pt Task, peerTaskRequest *scheduler.PeerTaskRequest, parsedRange *clientutil.Range, metadata *source.Metadata, startPieceNum int32) error {
func (pm *pieceManager) concurrentDownloadSource(ctx context.Context, pt Task, peerTaskRequest *schedulerv1.PeerTaskRequest, parsedRange *clientutil.Range, metadata *source.Metadata, startPieceNum int32) error {
// parsedRange is always exist
pieceSize := pm.computePieceSize(parsedRange.Length)
pieceCount := util.ComputePieceCount(parsedRange.Length, pieceSize)
@ -836,7 +837,7 @@ func (pm *pieceManager) concurrentDownloadSource(ctx context.Context, pt Task, p
func (pm *pieceManager) downloadPieceFromSource(ctx context.Context,
pt Task, log *logger.SugaredLoggerOnWith,
peerTaskRequest *scheduler.PeerTaskRequest,
peerTaskRequest *schedulerv1.PeerTaskRequest,
pieceSize uint32, num int32,
parsedRange *clientutil.Range,
pieceCount int32,
@ -881,7 +882,7 @@ func (pm *pieceManager) downloadPieceFromSource(ctx context.Context,
request := &DownloadPieceRequest{
TaskID: pt.GetTaskID(),
PeerID: pt.GetPeerID(),
piece: &base.PieceInfo{
piece: &commonv1.PieceInfo{
PieceNum: num,
RangeStart: offset,
RangeSize: uint32(result.Size),

9
client/daemon/peer/piece_manager_test.go
View File

@ -36,15 +36,16 @@ import (
"go.uber.org/atomic"
"golang.org/x/time/rate"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/test"
clientutil "d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/internal/util"
"d7y.io/dragonfly/v2/pkg/rpc/base"
_ "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/source"
"d7y.io/dragonfly/v2/pkg/source/clients/httpprotocol"
)
@ -443,9 +444,9 @@ func TestPieceManager_DownloadSource(t *testing.T) {
return tc.pieceSize
}
request := &scheduler.PeerTaskRequest{
request := &schedulerv1.PeerTaskRequest{
Url: ts.URL,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: "",
Range: "",
Header: nil,

15
client/daemon/proxy/proxy.go
View File

@ -39,13 +39,14 @@ import (
"go.uber.org/atomic"
"golang.org/x/sync/semaphore"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/daemon/transport"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
pkgstrings "d7y.io/dragonfly/v2/pkg/strings"
)
@ -85,7 +86,7 @@ type Proxy struct {
peerTaskManager peer.TaskManager
// peerHost is the peer host info
peerHost *scheduler.PeerHost
peerHost *schedulerv1.PeerHost
// whiteList is the proxy white list
whiteList []*config.WhiteList
@ -100,7 +101,7 @@ type Proxy struct {
defaultTag string
// defaultFilter is used for registering steam task
defaultPattern base.Pattern
defaultPattern commonv1.Pattern
// tracer is used for telemetry
tracer trace.Tracer
@ -116,8 +117,8 @@ type Proxy struct {
// Option is a functional option for configuring the proxy
type Option func(p *Proxy) *Proxy
// WithPeerHost sets the *scheduler.PeerHost
func WithPeerHost(peerHost *scheduler.PeerHost) Option {
// WithPeerHost sets the *schedulerv1.PeerHost
func WithPeerHost(peerHost *schedulerv1.PeerHost) Option {
return func(p *Proxy) *Proxy {
p.peerHost = peerHost
return p
@ -226,7 +227,7 @@ func WithDefaultTag(t string) Option {
}
// WithDefaultPattern sets default pattern for downloading
func WithDefaultPattern(pattern base.Pattern) Option {
func WithDefaultPattern(pattern commonv1.Pattern) Option {
return func(p *Proxy) *Proxy {
p.defaultPattern = pattern
return p

7
client/daemon/proxy/proxy_manager.go
View File

@ -32,11 +32,12 @@ import (
"github.com/spf13/viper"
"gopkg.in/yaml.v3"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/peer"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
type Manager interface {
@ -59,7 +60,7 @@ type proxyManager struct {
var _ Manager = (*proxyManager)(nil)
func NewProxyManager(peerHost *scheduler.PeerHost, peerTaskManager peer.TaskManager, defaultPattern base.Pattern, proxyOption *config.ProxyOption) (Manager, error) {
func NewProxyManager(peerHost *schedulerv1.PeerHost, peerTaskManager peer.TaskManager, defaultPattern commonv1.Pattern, proxyOption *config.ProxyOption) (Manager, error) {
// proxy is option, when nil, just disable it
if proxyOption == nil {
logger.Infof("proxy config is empty, disabled")

99
client/daemon/rpcserver/rpcserver.go
View File

@ -35,6 +35,11 @@ import (
healthpb "google.golang.org/grpc/health/grpc_health_v1"
"google.golang.org/grpc/status"
cdnsystemv1 "d7y.io/api/pkg/apis/cdnsystem/v1"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/daemon/storage"
@ -43,11 +48,7 @@ import (
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/net/http"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
dfdaemongrpc "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
dfdaemonserver "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/safe"
"d7y.io/dragonfly/v2/scheduler/resource"
)
@ -61,18 +62,18 @@ type Server interface {
type server struct {
util.KeepAlive
peerHost *scheduler.PeerHost
peerHost *schedulerv1.PeerHost
peerTaskManager peer.TaskManager
storageManager storage.Manager
defaultPattern base.Pattern
defaultPattern commonv1.Pattern
downloadServer *grpc.Server
peerServer *grpc.Server
uploadAddr string
}
func New(peerHost *scheduler.PeerHost, peerTaskManager peer.TaskManager,
storageManager storage.Manager, defaultPattern base.Pattern,
func New(peerHost *schedulerv1.PeerHost, peerTaskManager peer.TaskManager,
storageManager storage.Manager, defaultPattern commonv1.Pattern,
downloadOpts []grpc.ServerOption, peerOpts []grpc.ServerOption) (Server, error) {
s := &server{
KeepAlive: util.NewKeepAlive("rpc server"),
@ -92,7 +93,7 @@ func New(peerHost *scheduler.PeerHost, peerTaskManager peer.TaskManager,
s.peerServer = dfdaemonserver.New(s, peerOpts...)
healthpb.RegisterHealthServer(s.peerServer, health.NewServer())
cdnsystem.RegisterSeederServer(s.peerServer, sd)
cdnsystemv1.RegisterSeederServer(s.peerServer, sd)
return s, nil
}
@ -110,13 +111,13 @@ func (s *server) Stop() {
s.downloadServer.GracefulStop()
}
func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (s *server) GetPieceTasks(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
s.Keep()
p, err := s.storageManager.GetPieces(ctx, request)
if err != nil {
code := base.Code_UnknownError
code := commonv1.Code_UnknownError
if err == dferrors.ErrInvalidArgument {
code = base.Code_BadRequest
code = commonv1.Code_BadRequest
}
if err != storage.ErrTaskNotFound {
logger.Errorf("get piece tasks error: %s, task id: %s, src peer: %s, dst peer: %s, piece num: %d, limit: %d",
@ -126,7 +127,7 @@ func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskReque
// dst peer is not running
task, ok := s.peerTaskManager.IsPeerTaskRunning(request.TaskId)
if !ok {
code = base.Code_PeerTaskNotFound
code = commonv1.Code_PeerTaskNotFound
logger.Errorf("get piece tasks error: target peer task not found, task id: %s, src peer: %s, dst peer: %s, piece num: %d, limit: %d",
request.TaskId, request.SrcPid, request.DstPid, request.StartNum, request.Limit)
return nil, dferrors.New(code, err.Error())
@ -134,7 +135,7 @@ func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskReque
if task.GetPeerID() != request.GetDstPid() {
// there is only one running task in same time, redirect request to running peer task
r := base.PieceTaskRequest{
r := commonv1.PieceTaskRequest{
TaskId: request.TaskId,
SrcPid: request.SrcPid,
DstPid: task.GetPeerID(), // replace to running task peer id
@ -148,7 +149,7 @@ func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskReque
p.DstAddr = s.uploadAddr
return p, nil
}
code = base.Code_PeerTaskNotFound
code = commonv1.Code_PeerTaskNotFound
logger.Errorf("get piece tasks error: target peer task and replaced peer task storage not found wit error: %s, task id: %s, src peer: %s, dst peer: %s, piece num: %d, limit: %d",
err, request.TaskId, request.SrcPid, request.DstPid, request.StartNum, request.Limit)
return nil, dferrors.New(code, err.Error())
@ -160,7 +161,7 @@ func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskReque
"task id: %s, src peer: %s, dst peer: %s, piece num: %d, limit: %d",
request.TaskId, request.SrcPid, request.DstPid, request.StartNum, request.Limit)
// dst peer is running, send empty result, src peer will retry later
return &base.PiecePacket{
return &commonv1.PiecePacket{
TaskId: request.TaskId,
DstPid: request.DstPid,
DstAddr: s.uploadAddr,
@ -180,9 +181,9 @@ func (s *server) GetPieceTasks(ctx context.Context, request *base.PieceTaskReque
// sendExistPieces will send as much as possible pieces
func (s *server) sendExistPieces(
log *logger.SugaredLoggerOnWith,
request *base.PieceTaskRequest,
sync dfdaemongrpc.Daemon_SyncPieceTasksServer,
get func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error),
request *commonv1.PieceTaskRequest,
sync dfdaemonv1.Daemon_SyncPieceTasksServer,
get func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error),
sentMap map[int32]struct{}) (total int32, err error) {
return sendExistPieces(sync.Context(), log, get, request, sync, sentMap, true)
}
@ -190,14 +191,14 @@ func (s *server) sendExistPieces(
// sendFirstPieceTasks will send as much as possible pieces, even if no available pieces
func (s *server) sendFirstPieceTasks(
log *logger.SugaredLoggerOnWith,
request *base.PieceTaskRequest,
sync dfdaemongrpc.Daemon_SyncPieceTasksServer,
get func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error),
request *commonv1.PieceTaskRequest,
sync dfdaemonv1.Daemon_SyncPieceTasksServer,
get func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error),
sentMap map[int32]struct{}) (total int32, err error) {
return sendExistPieces(sync.Context(), log, get, request, sync, sentMap, false)
}
func (s *server) SyncPieceTasks(sync dfdaemongrpc.Daemon_SyncPieceTasksServer) error {
func (s *server) SyncPieceTasks(sync dfdaemonv1.Daemon_SyncPieceTasksServer) error {
request, err := sync.Recv()
if err != nil {
logger.Errorf("receive first sync piece tasks request error: %s", err.Error())
@ -212,7 +213,7 @@ func (s *server) SyncPieceTasks(sync dfdaemongrpc.Daemon_SyncPieceTasksServer) e
attributeSent bool
)
getPieces := func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
getPieces := func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
p, e := s.GetPieceTasks(ctx, request)
if e != nil {
return nil, e
@ -305,15 +306,15 @@ func (s *server) CheckHealth(context.Context) error {
}
func (s *server) Download(ctx context.Context,
req *dfdaemongrpc.DownRequest, results chan<- *dfdaemongrpc.DownResult) error {
req *dfdaemonv1.DownRequest, results chan<- *dfdaemonv1.DownResult) error {
s.Keep()
return s.doDownload(ctx, req, results, "")
}
func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
results chan<- *dfdaemongrpc.DownResult, peerID string) error {
func (s *server) doDownload(ctx context.Context, req *dfdaemonv1.DownRequest,
results chan<- *dfdaemonv1.DownResult, peerID string) error {
if req.UrlMeta == nil {
req.UrlMeta = &base.UrlMeta{}
req.UrlMeta = &commonv1.UrlMeta{}
}
// init peer task request, peer uses different peer id to generate every request
@ -322,7 +323,7 @@ func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
peerID = idgen.PeerID(s.peerHost.Ip)
}
peerTask := &peer.FileTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
Url: req.Url,
UrlMeta: req.UrlMeta,
PeerId: peerID,
@ -350,10 +351,10 @@ func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
peerTaskProgress, tiny, err := s.peerTaskManager.StartFileTask(ctx, peerTask)
if err != nil {
return dferrors.New(base.Code_UnknownError, fmt.Sprintf("%s", err))
return dferrors.New(commonv1.Code_UnknownError, fmt.Sprintf("%s", err))
}
if tiny != nil {
results <- &dfdaemongrpc.DownResult{
results <- &dfdaemonv1.DownResult{
TaskId: tiny.TaskID,
PeerId: tiny.PeerID,
CompletedLength: uint64(len(tiny.Content)),
@ -375,13 +376,13 @@ func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
if !ok {
err = errors.New("progress closed unexpected")
log.Errorf(err.Error())
return dferrors.New(base.Code_UnknownError, err.Error())
return dferrors.New(commonv1.Code_UnknownError, err.Error())
}
if !p.State.Success {
log.Errorf("task %s/%s failed: %d/%s", p.PeerID, p.TaskID, p.State.Code, p.State.Msg)
return dferrors.New(p.State.Code, p.State.Msg)
}
results <- &dfdaemongrpc.DownResult{
results <- &dfdaemonv1.DownResult{
TaskId: p.TaskID,
PeerId: p.PeerID,
CompletedLength: uint64(p.CompletedLength),
@ -401,7 +402,7 @@ func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
return nil
}
case <-ctx.Done():
results <- &dfdaemongrpc.DownResult{
results <- &dfdaemonv1.DownResult{
CompletedLength: 0,
Done: true,
}
@ -411,7 +412,7 @@ func (s *server) doDownload(ctx context.Context, req *dfdaemongrpc.DownRequest,
}
}
func (s *server) StatTask(ctx context.Context, req *dfdaemongrpc.StatTaskRequest) error {
func (s *server) StatTask(ctx context.Context, req *dfdaemonv1.StatTaskRequest) error {
s.Keep()
taskID := idgen.TaskID(req.Url, req.UrlMeta)
log := logger.With("function", "StatTask", "URL", req.Url, "Tag", req.UrlMeta.Tag, "taskID", taskID, "LocalOnly", req.LocalOnly)
@ -426,7 +427,7 @@ func (s *server) StatTask(ctx context.Context, req *dfdaemongrpc.StatTaskRequest
if req.LocalOnly {
msg := "task not found in local cache"
log.Info(msg)
return dferrors.New(base.Code_PeerTaskNotFound, msg)
return dferrors.New(commonv1.Code_PeerTaskNotFound, msg)
}
// Check scheduler if other peers hold the task
@ -440,14 +441,14 @@ func (s *server) StatTask(ctx context.Context, req *dfdaemongrpc.StatTaskRequest
}
msg := fmt.Sprintf("task found but not available for download, state %s, has available peer %t", task.State, task.HasAvailablePeer)
log.Info(msg)
return dferrors.New(base.Code_PeerTaskNotFound, msg)
return dferrors.New(commonv1.Code_PeerTaskNotFound, msg)
}
func (s *server) isTaskCompleted(taskID string) bool {
return s.storageManager.FindCompletedTask(taskID) != nil
}
func (s *server) ImportTask(ctx context.Context, req *dfdaemongrpc.ImportTaskRequest) error {
func (s *server) ImportTask(ctx context.Context, req *dfdaemonv1.ImportTaskRequest) error {
s.Keep()
peerID := idgen.PeerID(s.peerHost.Ip)
taskID := idgen.TaskID(req.Url, req.UrlMeta)
@ -509,7 +510,7 @@ func (s *server) ImportTask(ctx context.Context, req *dfdaemongrpc.ImportTaskReq
return nil
}
func (s *server) ExportTask(ctx context.Context, req *dfdaemongrpc.ExportTaskRequest) error {
func (s *server) ExportTask(ctx context.Context, req *dfdaemonv1.ExportTaskRequest) error {
s.Keep()
taskID := idgen.TaskID(req.Url, req.UrlMeta)
log := logger.With("function", "ExportTask", "URL", req.Url, "Tag", req.UrlMeta.Tag, "taskID", taskID, "destination", req.Output)
@ -521,7 +522,7 @@ func (s *server) ExportTask(ctx context.Context, req *dfdaemongrpc.ExportTaskReq
if req.LocalOnly {
msg := fmt.Sprintf("task not found in local storage")
log.Info(msg)
return dferrors.New(base.Code_PeerTaskNotFound, msg)
return dferrors.New(commonv1.Code_PeerTaskNotFound, msg)
}
log.Info("task not found, try from peers")
return s.exportFromPeers(ctx, log, req)
@ -534,7 +535,7 @@ func (s *server) ExportTask(ctx context.Context, req *dfdaemongrpc.ExportTaskReq
return nil
}
func (s *server) exportFromLocal(ctx context.Context, req *dfdaemongrpc.ExportTaskRequest, peerID string) error {
func (s *server) exportFromLocal(ctx context.Context, req *dfdaemonv1.ExportTaskRequest, peerID string) error {
return s.storageManager.Store(ctx, &storage.StoreRequest{
CommonTaskRequest: storage.CommonTaskRequest{
PeerID: peerID,
@ -545,13 +546,13 @@ func (s *server) exportFromLocal(ctx context.Context, req *dfdaemongrpc.ExportTa
})
}
func (s *server) exportFromPeers(ctx context.Context, log *logger.SugaredLoggerOnWith, req *dfdaemongrpc.ExportTaskRequest) error {
func (s *server) exportFromPeers(ctx context.Context, log *logger.SugaredLoggerOnWith, req *dfdaemonv1.ExportTaskRequest) error {
peerID := idgen.PeerID(s.peerHost.Ip)
taskID := idgen.TaskID(req.Url, req.UrlMeta)
task, err := s.peerTaskManager.StatTask(ctx, taskID)
if err != nil {
if dferrors.CheckError(err, base.Code_PeerTaskNotFound) {
if dferrors.CheckError(err, commonv1.Code_PeerTaskNotFound) {
log.Info("task not found in P2P network")
} else {
msg := fmt.Sprintf("failed to StatTask from peers: %s", err)
@ -562,18 +563,18 @@ func (s *server) exportFromPeers(ctx context.Context, log *logger.SugaredLoggerO
if task.State != resource.TaskStateSucceeded || !task.HasAvailablePeer {
msg := fmt.Sprintf("task found but not available for download, state %s, has available peer %t", task.State, task.HasAvailablePeer)
log.Info(msg)
return dferrors.New(base.Code_PeerTaskNotFound, msg)
return dferrors.New(commonv1.Code_PeerTaskNotFound, msg)
}
// Task exists in peers
var (
start = time.Now()
drc = make(chan *dfdaemongrpc.DownResult, 1)
drc = make(chan *dfdaemonv1.DownResult, 1)
errChan = make(chan error, 3)
result *dfdaemongrpc.DownResult
result *dfdaemonv1.DownResult
downError error
)
downRequest := &dfdaemongrpc.DownRequest{
downRequest := &dfdaemonv1.DownRequest{
Url: req.Url,
Output: req.Output,
Timeout: req.Timeout,
@ -609,7 +610,7 @@ func (s *server) exportFromPeers(ctx context.Context, log *logger.SugaredLoggerO
return nil
}
func call(ctx context.Context, peerID string, drc chan *dfdaemongrpc.DownResult, s *server, req *dfdaemongrpc.DownRequest, errChan chan error) {
func call(ctx context.Context, peerID string, drc chan *dfdaemonv1.DownResult, s *server, req *dfdaemonv1.DownRequest, errChan chan error) {
err := safe.Call(func() {
if err := s.doDownload(ctx, req, drc, peerID); err != nil {
errChan <- err
@ -621,7 +622,7 @@ func call(ctx context.Context, peerID string, drc chan *dfdaemongrpc.DownResult,
}
}
func (s *server) DeleteTask(ctx context.Context, req *dfdaemongrpc.DeleteTaskRequest) error {
func (s *server) DeleteTask(ctx context.Context, req *dfdaemonv1.DeleteTaskRequest) error {
s.Keep()
taskID := idgen.TaskID(req.Url, req.UrlMeta)
log := logger.With("function", "DeleteTask", "URL", req.Url, "Tag", req.UrlMeta.Tag, "taskID", taskID)

77
client/daemon/rpcserver/rpcserver_test.go
View File

@ -30,6 +30,10 @@ import (
"github.com/phayes/freeport"
testifyassert "github.com/stretchr/testify/assert"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/storage/mocks"
@ -37,11 +41,8 @@ import (
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/net/ip"
"d7y.io/dragonfly/v2/pkg/rpc/base"
dfdaemongrpc "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
dfclient "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
dfdaemonserver "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
func TestMain(m *testing.M) {
@ -77,17 +78,17 @@ func Test_ServeDownload(t *testing.T) {
})
m := &server{
KeepAlive: util.NewKeepAlive("test"),
peerHost: &scheduler.PeerHost{},
peerHost: &schedulerv1.PeerHost{},
peerTaskManager: mockPeerTaskManager,
}
m.downloadServer = dfdaemonserver.New(m)
_, client := setupPeerServerAndClient(t, m, assert, m.ServeDownload)
request := &dfdaemongrpc.DownRequest{
request := &dfdaemonv1.DownRequest{
Uuid: uuid.Generate().String(),
Url: "http://localhost/test",
Output: "./testdata/file1",
DisableBackSource: false,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: "unit test",
},
Pattern: "p2p",
@ -97,8 +98,8 @@ func Test_ServeDownload(t *testing.T) {
assert.Nil(err, "client download grpc call should be ok")
var (
lastResult *dfdaemongrpc.DownResult
curResult *dfdaemongrpc.DownResult
lastResult *dfdaemonv1.DownResult
curResult *dfdaemonv1.DownResult
)
for {
curResult, err = down.Recv()
@ -119,22 +120,22 @@ func Test_ServePeer(t *testing.T) {
var maxPieceNum uint32 = 10
mockStorageManger := mocks.NewMockManager(ctrl)
mockStorageManger.EXPECT().GetPieces(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(func(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
mockStorageManger.EXPECT().GetPieces(gomock.Any(), gomock.Any()).AnyTimes().DoAndReturn(func(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
var (
pieces []*base.PieceInfo
pieces []*commonv1.PieceInfo
pieceSize = uint32(1024)
)
for i := req.StartNum; i < req.Limit+req.StartNum && i < maxPieceNum; i++ {
pieces = append(pieces, &base.PieceInfo{
pieces = append(pieces, &commonv1.PieceInfo{
PieceNum: int32(i),
RangeStart: uint64(i * pieceSize),
RangeSize: pieceSize,
PieceMd5: "",
PieceOffset: uint64(i * pieceSize),
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
})
}
return &base.PiecePacket{
return &commonv1.PiecePacket{
TaskId: "",
DstPid: "",
DstAddr: "",
@ -146,7 +147,7 @@ func Test_ServePeer(t *testing.T) {
})
s := &server{
KeepAlive: util.NewKeepAlive("test"),
peerHost: &scheduler.PeerHost{},
peerHost: &schedulerv1.PeerHost{},
storageManager: mockStorageManger,
}
s.peerServer = dfdaemonserver.New(s)
@ -154,12 +155,12 @@ func Test_ServePeer(t *testing.T) {
defer s.peerServer.GracefulStop()
var tests = []struct {
request *base.PieceTaskRequest
request *commonv1.PieceTaskRequest
responsePieceSize int
}{
{
request: &base.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &base.UrlMeta{}),
request: &commonv1.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &commonv1.UrlMeta{}),
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),
StartNum: 0,
@ -169,8 +170,8 @@ func Test_ServePeer(t *testing.T) {
responsePieceSize: 1,
},
{
request: &base.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &base.UrlMeta{}),
request: &commonv1.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &commonv1.UrlMeta{}),
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),
StartNum: 0,
@ -180,8 +181,8 @@ func Test_ServePeer(t *testing.T) {
responsePieceSize: 4,
},
{
request: &base.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &base.UrlMeta{}),
request: &commonv1.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &commonv1.UrlMeta{}),
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),
StartNum: 8,
@ -191,8 +192,8 @@ func Test_ServePeer(t *testing.T) {
responsePieceSize: 1,
},
{
request: &base.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &base.UrlMeta{}),
request: &commonv1.PieceTaskRequest{
TaskId: idgen.TaskID("http://www.test.com", &commonv1.UrlMeta{}),
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),
StartNum: 8,
@ -373,11 +374,11 @@ func Test_SyncPieceTasks(t *testing.T) {
}
var (
totalPieces []*base.PieceInfo
totalPieces []*commonv1.PieceInfo
lock sync.Mutex
)
var addedPieces = make(map[uint32]*base.PieceInfo)
var addedPieces = make(map[uint32]*commonv1.PieceInfo)
for _, p := range tc.existPieces {
if p.end == 0 {
p.end = p.start
@ -386,12 +387,12 @@ func Test_SyncPieceTasks(t *testing.T) {
if _, ok := addedPieces[uint32(i)]; ok {
continue
}
piece := &base.PieceInfo{
piece := &commonv1.PieceInfo{
PieceNum: int32(i),
RangeStart: uint64(i) * uint64(pieceSize),
RangeSize: pieceSize,
PieceOffset: uint64(i) * uint64(pieceSize),
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
}
totalPieces = append(totalPieces, piece)
addedPieces[uint32(i)] = piece
@ -400,8 +401,8 @@ func Test_SyncPieceTasks(t *testing.T) {
mockStorageManger.EXPECT().GetPieces(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
var pieces []*base.PieceInfo
func(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
var pieces []*commonv1.PieceInfo
lock.Lock()
for i := req.StartNum; i < tc.totalPieces; i++ {
if piece, ok := addedPieces[i]; ok {
@ -411,7 +412,7 @@ func Test_SyncPieceTasks(t *testing.T) {
}
}
lock.Unlock()
return &base.PiecePacket{
return &commonv1.PiecePacket{
TaskId: req.TaskId,
DstPid: req.DstPid,
DstAddr: "",
@ -423,8 +424,8 @@ func Test_SyncPieceTasks(t *testing.T) {
})
mockStorageManger.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -432,7 +433,7 @@ func Test_SyncPieceTasks(t *testing.T) {
})
mockTaskManager := peer.NewMockTaskManager(ctrl)
mockTaskManager.EXPECT().Subscribe(gomock.Any()).AnyTimes().DoAndReturn(
func(request *base.PieceTaskRequest) (*peer.SubscribeResponse, bool) {
func(request *commonv1.PieceTaskRequest) (*peer.SubscribeResponse, bool) {
ch := make(chan *peer.PieceInfo)
success := make(chan struct{})
fail := make(chan struct{})
@ -447,12 +448,12 @@ func Test_SyncPieceTasks(t *testing.T) {
if _, ok := addedPieces[uint32(j)]; ok {
continue
}
piece := &base.PieceInfo{
piece := &commonv1.PieceInfo{
PieceNum: int32(j),
RangeStart: uint64(j) * uint64(pieceSize),
RangeSize: pieceSize,
PieceOffset: uint64(j) * uint64(pieceSize),
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
}
totalPieces = append(totalPieces, piece)
addedPieces[uint32(j)] = piece
@ -483,7 +484,7 @@ func Test_SyncPieceTasks(t *testing.T) {
s := &server{
KeepAlive: util.NewKeepAlive("test"),
peerHost: &scheduler.PeerHost{},
peerHost: &schedulerv1.PeerHost{},
storageManager: mockStorageManger,
peerTaskManager: mockTaskManager,
}
@ -496,7 +497,7 @@ func Test_SyncPieceTasks(t *testing.T) {
Type: dfnet.TCP,
Addr: fmt.Sprintf("127.0.0.1:%d", port),
},
&base.PieceTaskRequest{
&commonv1.PieceTaskRequest{
TaskId: tc.name,
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),
@ -515,7 +516,7 @@ func Test_SyncPieceTasks(t *testing.T) {
} else {
go func() {
for _, n := range tc.requestPieces {
request := &base.PieceTaskRequest{
request := &commonv1.PieceTaskRequest{
TaskId: tc.name,
SrcPid: idgen.PeerID(ip.IPv4),
DstPid: idgen.PeerID(ip.IPv4),

33
client/daemon/rpcserver/seeder.go
View File

@ -25,6 +25,10 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
cdnsystemv1 "d7y.io/api/pkg/apis/cdnsystem/v1"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/peer"
@ -32,36 +36,33 @@ import (
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/net/http"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/base/common"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/rpc/common"
)
type seeder struct {
server *server
}
func (s *seeder) GetPieceTasks(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (s *seeder) GetPieceTasks(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
return s.server.GetPieceTasks(ctx, request)
}
func (s *seeder) SyncPieceTasks(tasksServer cdnsystem.Seeder_SyncPieceTasksServer) error {
func (s *seeder) SyncPieceTasks(tasksServer cdnsystemv1.Seeder_SyncPieceTasksServer) error {
return s.server.SyncPieceTasks(tasksServer)
}
func (s *seeder) ObtainSeeds(seedRequest *cdnsystem.SeedRequest, seedsServer cdnsystem.Seeder_ObtainSeedsServer) error {
func (s *seeder) ObtainSeeds(seedRequest *cdnsystemv1.SeedRequest, seedsServer cdnsystemv1.Seeder_ObtainSeedsServer) error {
metrics.SeedPeerConcurrentDownloadGauge.Inc()
defer metrics.SeedPeerConcurrentDownloadGauge.Dec()
metrics.SeedPeerDownloadCount.Add(1)
s.server.Keep()
if seedRequest.UrlMeta == nil {
seedRequest.UrlMeta = &base.UrlMeta{}
seedRequest.UrlMeta = &commonv1.UrlMeta{}
}
req := peer.SeedTaskRequest{
PeerTaskRequest: scheduler.PeerTaskRequest{
PeerTaskRequest: schedulerv1.PeerTaskRequest{
Url: seedRequest.Url,
UrlMeta: seedRequest.UrlMeta,
PeerId: idgen.SeedPeerID(s.server.peerHost.Ip), // when reuse peer task, peer id will be replaced.
@ -114,10 +115,10 @@ func (s *seeder) ObtainSeeds(seedRequest *cdnsystem.SeedRequest, seedsServer cdn
log.Infof("start seed task")
err = seedsServer.Send(
&cdnsystem.PieceSeed{
&cdnsystemv1.PieceSeed{
PeerId: resp.PeerID,
HostId: req.PeerHost.Id,
PieceInfo: &base.PieceInfo{
PieceInfo: &commonv1.PieceInfo{
PieceNum: common.BeginOfPiece,
},
Done: false,
@ -149,7 +150,7 @@ func (s *seeder) ObtainSeeds(seedRequest *cdnsystem.SeedRequest, seedsServer cdn
type seedSynchronizer struct {
*peer.SeedTaskResponse
*logger.SugaredLoggerOnWith
seedsServer cdnsystem.Seeder_ObtainSeedsServer
seedsServer cdnsystemv1.Seeder_ObtainSeedsServer
seedTaskRequest *peer.SeedTaskRequest
startNanoSecond int64
attributeSent bool
@ -210,7 +211,7 @@ func (s *seedSynchronizer) sendPieceSeeds(reuse bool) (err error) {
func (s *seedSynchronizer) sendRemindingPieceSeeds(desired int32, reuse bool) error {
for {
pp, err := s.Storage.GetPieces(s.Context,
&base.PieceTaskRequest{
&commonv1.PieceTaskRequest{
TaskId: s.TaskID,
StartNum: uint32(desired),
Limit: 16,
@ -274,7 +275,7 @@ func (s *seedSynchronizer) sendOrderedPieceSeeds(desired, orderedNum int32, fini
var contentLength int64 = -1
for ; cur <= orderedNum; cur++ {
pp, err := s.Storage.GetPieces(s.Context,
&base.PieceTaskRequest{
&commonv1.PieceTaskRequest{
TaskId: s.TaskID,
StartNum: uint32(cur),
Limit: 1,
@ -314,8 +315,8 @@ func (s *seedSynchronizer) sendOrderedPieceSeeds(desired, orderedNum int32, fini
return contentLength, cur, nil
}
func (s *seedSynchronizer) compositePieceSeed(pp *base.PiecePacket, piece *base.PieceInfo) cdnsystem.PieceSeed {
return cdnsystem.PieceSeed{
func (s *seedSynchronizer) compositePieceSeed(pp *commonv1.PiecePacket, piece *commonv1.PieceInfo) cdnsystemv1.PieceSeed {
return cdnsystemv1.PieceSeed{
PeerId: s.seedTaskRequest.PeerId,
HostId: s.seedTaskRequest.PeerHost.Id,
PieceInfo: piece,

43
client/daemon/rpcserver/seeder_test.go
View File

@ -30,18 +30,19 @@ import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/trace"
cdnsystemv1 "d7y.io/api/pkg/apis/cdnsystem/v1"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/daemon/storage"
"d7y.io/dragonfly/v2/client/daemon/storage/mocks"
"d7y.io/dragonfly/v2/client/util"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/base/common"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
cdnclient "d7y.io/dragonfly/v2/pkg/rpc/cdnsystem/client"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem/client"
"d7y.io/dragonfly/v2/pkg/rpc/common"
dfdaemonserver "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
func Test_ObtainSeeds(t *testing.T) {
@ -196,11 +197,11 @@ func Test_ObtainSeeds(t *testing.T) {
}
var (
totalPieces []*base.PieceInfo
totalPieces []*commonv1.PieceInfo
lock sync.Mutex
)
var addedPieces = make(map[uint32]*base.PieceInfo)
var addedPieces = make(map[uint32]*commonv1.PieceInfo)
for _, p := range tc.existPieces {
if p.end == 0 {
p.end = p.start
@ -209,12 +210,12 @@ func Test_ObtainSeeds(t *testing.T) {
if _, ok := addedPieces[uint32(i)]; ok {
continue
}
piece := &base.PieceInfo{
piece := &commonv1.PieceInfo{
PieceNum: int32(i),
RangeStart: uint64(i) * uint64(pieceSize),
RangeSize: pieceSize,
PieceOffset: uint64(i) * uint64(pieceSize),
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
}
totalPieces = append(totalPieces, piece)
addedPieces[uint32(i)] = piece
@ -223,8 +224,8 @@ func Test_ObtainSeeds(t *testing.T) {
mockStorageManger.EXPECT().GetPieces(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
var pieces []*base.PieceInfo
func(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
var pieces []*commonv1.PieceInfo
lock.Lock()
for i := req.StartNum; i < tc.totalPieces; i++ {
if piece, ok := addedPieces[i]; ok {
@ -234,7 +235,7 @@ func Test_ObtainSeeds(t *testing.T) {
}
}
lock.Unlock()
return &base.PiecePacket{
return &commonv1.PiecePacket{
TaskId: req.TaskId,
DstPid: req.DstPid,
DstAddr: "",
@ -246,8 +247,8 @@ func Test_ObtainSeeds(t *testing.T) {
})
mockStorageManger.EXPECT().GetExtendAttribute(gomock.Any(),
gomock.Any()).AnyTimes().DoAndReturn(
func(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
return &base.ExtendAttribute{
func(ctx context.Context, req *storage.PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
return &commonv1.ExtendAttribute{
Header: map[string]string{
"Test": "test",
},
@ -270,12 +271,12 @@ func Test_ObtainSeeds(t *testing.T) {
if _, ok := addedPieces[uint32(j)]; ok {
continue
}
piece := &base.PieceInfo{
piece := &commonv1.PieceInfo{
PieceNum: int32(j),
RangeStart: uint64(j) * uint64(pieceSize),
RangeSize: pieceSize,
PieceOffset: uint64(j) * uint64(pieceSize),
PieceStyle: base.PieceStyle_PLAIN,
PieceStyle: commonv1.PieceStyle_PLAIN,
}
totalPieces = append(totalPieces, piece)
addedPieces[uint32(j)] = piece
@ -313,7 +314,7 @@ func Test_ObtainSeeds(t *testing.T) {
s := &server{
KeepAlive: util.NewKeepAlive("test"),
peerHost: &scheduler.PeerHost{},
peerHost: &schedulerv1.PeerHost{},
storageManager: mockStorageManger,
peerTaskManager: mockTaskManager,
}
@ -323,7 +324,7 @@ func Test_ObtainSeeds(t *testing.T) {
pps, err := client.ObtainSeeds(
context.Background(),
&cdnsystem.SeedRequest{
&cdnsystemv1.SeedRequest{
TaskId: "fake-task-id",
Url: "http://localhost/path/to/file",
UrlMeta: nil,
@ -361,9 +362,9 @@ func Test_ObtainSeeds(t *testing.T) {
}
}
func setupSeederServerAndClient(t *testing.T, srv *server, sd *seeder, assert *testifyassert.Assertions, serveFunc func(listener net.Listener) error) (int, cdnclient.CdnClient) {
func setupSeederServerAndClient(t *testing.T, srv *server, sd *seeder, assert *testifyassert.Assertions, serveFunc func(listener net.Listener) error) (int, client.CdnClient) {
srv.peerServer = dfdaemonserver.New(srv)
cdnsystem.RegisterSeederServer(srv.peerServer, sd)
cdnsystemv1.RegisterSeederServer(srv.peerServer, sd)
port, err := freeport.GetFreePort()
if err != nil {
@ -378,7 +379,7 @@ func setupSeederServerAndClient(t *testing.T, srv *server, sd *seeder, assert *t
}
}()
client := cdnclient.GetClientByAddr([]dfnet.NetAddr{
client := client.GetClientByAddr([]dfnet.NetAddr{
{
Type: dfnet.TCP,
Addr: fmt.Sprintf(":%d", port),

21
client/daemon/rpcserver/subscriber.go
View File

@ -25,19 +25,20 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
)
type subscriber struct {
sync.Mutex // lock for sent map and grpc Send
*logger.SugaredLoggerOnWith
*peer.SubscribeResponse
sync dfdaemon.Daemon_SyncPieceTasksServer
request *base.PieceTaskRequest
sync dfdaemonv1.Daemon_SyncPieceTasksServer
request *commonv1.PieceTaskRequest
skipPieceCount uint32
totalPieces int32
sentMap map[int32]struct{}
@ -46,7 +47,7 @@ type subscriber struct {
attributeSent *atomic.Bool
}
func (s *subscriber) getPieces(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (s *subscriber) getPieces(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
p, err := s.Storage.GetPieces(ctx, request)
if err != nil {
return nil, err
@ -67,15 +68,15 @@ func (s *subscriber) getPieces(ctx context.Context, request *base.PieceTaskReque
func sendExistPieces(
ctx context.Context,
log *logger.SugaredLoggerOnWith,
get func(ctx context.Context, request *base.PieceTaskRequest) (*base.PiecePacket, error),
request *base.PieceTaskRequest,
sync dfdaemon.Daemon_SyncPieceTasksServer,
get func(ctx context.Context, request *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error),
request *commonv1.PieceTaskRequest,
sync dfdaemonv1.Daemon_SyncPieceTasksServer,
sentMap map[int32]struct{},
skipSendZeroPiece bool) (total int32, err error) {
if request.Limit <= 0 {
request.Limit = 16
}
var pp *base.PiecePacket
var pp *commonv1.PiecePacket
for {
pp, err = get(ctx, request)
if err != nil {
@ -225,7 +226,7 @@ loop:
s.Unlock()
msg := "peer task success, but can not send all pieces"
s.Errorf(msg)
return dferrors.Newf(base.Code_ClientError, msg)
return dferrors.Newf(commonv1.Code_ClientError, msg)
}
s.Unlock()
break loop

13
client/daemon/storage/local_storage.go
View File

@ -30,11 +30,12 @@ import (
"go.uber.org/atomic"
commonv1 "d7y.io/api/pkg/apis/common/v1"
clientutil "d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/internal/util"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
type localTaskStore struct {
@ -396,7 +397,7 @@ func (t *localTaskStore) Store(ctx context.Context, req *StoreRequest) error {
return err
}
func (t *localTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (t *localTaskStore) GetPieces(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
if req == nil {
return nil, ErrBadRequest
}
@ -408,7 +409,7 @@ func (t *localTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskReque
t.RLock()
defer t.RUnlock()
t.touch()
piecePacket := &base.PiecePacket{
piecePacket := &commonv1.PiecePacket{
TaskId: req.TaskId,
DstPid: t.PeerID,
TotalPiece: t.TotalPieces,
@ -425,7 +426,7 @@ func (t *localTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskReque
}
if piece, ok := t.Pieces[num]; ok {
piecePacket.PieceInfos = append(piecePacket.PieceInfos,
&base.PieceInfo{
&commonv1.PieceInfo{
PieceNum: piece.Num,
RangeStart: uint64(piece.Range.Start),
RangeSize: uint32(piece.Range.Length),
@ -449,7 +450,7 @@ func (t *localTaskStore) GetTotalPieces(ctx context.Context, req *PeerTaskMetada
return t.TotalPieces, nil
}
func (t *localTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*base.ExtendAttribute, error) {
func (t *localTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
if t.invalid.Load() {
t.Errorf("invalid digest, refuse to get total pieces")
return nil, ErrInvalidDigest
@ -463,7 +464,7 @@ func (t *localTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTaskMe
hdr[k] = t.Header.Get(k)
}
}
return &base.ExtendAttribute{Header: hdr}, nil
return &commonv1.ExtendAttribute{Header: hdr}, nil
}
func (t *localTaskStore) CanReclaim() bool {

13
client/daemon/storage/local_storage_subtask.go
View File

@ -24,10 +24,11 @@ import (
"go.uber.org/atomic"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
// TODO need refactor with localTaskStore, currently, localSubTaskStore code copies from localTaskStore
@ -204,7 +205,7 @@ func (t *localSubTaskStore) ReadAllPieces(ctx context.Context, req *ReadAllPiece
}, nil
}
func (t *localSubTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (t *localSubTaskStore) GetPieces(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
if t.invalid.Load() {
t.Errorf("invalid digest, refuse to get pieces")
return nil, ErrInvalidDigest
@ -213,7 +214,7 @@ func (t *localSubTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskRe
t.RLock()
defer t.RUnlock()
t.parent.touch()
piecePacket := &base.PiecePacket{
piecePacket := &commonv1.PiecePacket{
TaskId: req.TaskId,
DstPid: t.PeerID,
TotalPiece: t.TotalPieces,
@ -227,7 +228,7 @@ func (t *localSubTaskStore) GetPieces(ctx context.Context, req *base.PieceTaskRe
for i := int32(0); i < int32(req.Limit); i++ {
if piece, ok := t.Pieces[int32(req.StartNum)+i]; ok {
piecePacket.PieceInfos = append(piecePacket.PieceInfos, &base.PieceInfo{
piecePacket.PieceInfos = append(piecePacket.PieceInfos, &commonv1.PieceInfo{
PieceNum: piece.Num,
RangeStart: uint64(piece.Range.Start),
RangeSize: uint32(piece.Range.Length),
@ -396,7 +397,7 @@ func (t *localSubTaskStore) Reclaim() error {
return nil
}
func (t *localSubTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*base.ExtendAttribute, error) {
func (t *localSubTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
if t.invalid.Load() {
t.Errorf("invalid digest, refuse to get total pieces")
return nil, ErrInvalidDigest
@ -410,5 +411,5 @@ func (t *localSubTaskStore) GetExtendAttribute(ctx context.Context, req *PeerTas
hdr[k] = t.Header.Get(k)
}
}
return &base.ExtendAttribute{Header: hdr}, nil
return &commonv1.ExtendAttribute{Header: hdr}, nil
}

7
client/daemon/storage/local_storage_test.go
View File

@ -31,13 +31,14 @@ import (
testifyassert "github.com/stretchr/testify/assert"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/test"
clientutil "d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/internal/util"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc/base"
_ "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/server"
)
@ -195,7 +196,7 @@ func TestLocalTaskStore_PutAndGetPiece(t *testing.T) {
Start: int64(p.start),
Length: int64(p.end - p.start),
},
Style: base.PieceStyle_PLAIN,
Style: commonv1.PieceStyle_PLAIN,
},
Reader: bytes.NewBuffer(testBytes[p.start:p.end]),
})
@ -225,7 +226,7 @@ func TestLocalTaskStore_PutAndGetPiece(t *testing.T) {
Start: int64(p.start),
Length: int64(p.end - p.start),
},
Style: base.PieceStyle_PLAIN,
Style: commonv1.PieceStyle_PLAIN,
},
})
assert.Nil(err, "get piece reader should be ok")

13
client/daemon/storage/metadata.go
View File

@ -19,8 +19,9 @@ package storage
import (
"io"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/util"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/source"
)
@ -44,11 +45,11 @@ type PeerTaskMetadata struct {
}
type PieceMetadata struct {
Num int32 `json:"num,omitempty"`
Md5 string `json:"md5,omitempty"`
Offset uint64 `json:"offset,omitempty"`
Range util.Range `json:"range,omitempty"`
Style base.PieceStyle `json:"style,omitempty"`
Num int32 `json:"num,omitempty"`
Md5 string `json:"md5,omitempty"`
Offset uint64 `json:"offset,omitempty"`
Range util.Range `json:"range,omitempty"`
Style commonv1.PieceStyle `json:"style,omitempty"`
// time(nanosecond) consumed
Cost uint64 `json:"cost,omitempty"`
}

18
client/daemon/storage/mocks/stroage_manager_mock.go
View File

@ -10,9 +10,9 @@ import (
reflect "reflect"
time "time"
v1 "d7y.io/api/pkg/apis/common/v1"
storage "d7y.io/dragonfly/v2/client/daemon/storage"
util "d7y.io/dragonfly/v2/client/util"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
gomock "github.com/golang/mock/gomock"
)
@ -40,10 +40,10 @@ func (m *MockTaskStorageDriver) EXPECT() *MockTaskStorageDriverMockRecorder {
}
// GetExtendAttribute mocks base method.
func (m *MockTaskStorageDriver) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
func (m *MockTaskStorageDriver) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*v1.ExtendAttribute, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetExtendAttribute", ctx, req)
ret0, _ := ret[0].(*base.ExtendAttribute)
ret0, _ := ret[0].(*v1.ExtendAttribute)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -55,10 +55,10 @@ func (mr *MockTaskStorageDriverMockRecorder) GetExtendAttribute(ctx, req interfa
}
// GetPieces mocks base method.
func (m *MockTaskStorageDriver) GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (m *MockTaskStorageDriver) GetPieces(ctx context.Context, req *v1.PieceTaskRequest) (*v1.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPieces", ctx, req)
ret0, _ := ret[0].(*base.PiecePacket)
ret0, _ := ret[0].(*v1.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -342,10 +342,10 @@ func (mr *MockManagerMockRecorder) FindPartialCompletedTask(taskID, rg interface
}
// GetExtendAttribute mocks base method.
func (m *MockManager) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*base.ExtendAttribute, error) {
func (m *MockManager) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*v1.ExtendAttribute, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetExtendAttribute", ctx, req)
ret0, _ := ret[0].(*base.ExtendAttribute)
ret0, _ := ret[0].(*v1.ExtendAttribute)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -357,10 +357,10 @@ func (mr *MockManagerMockRecorder) GetExtendAttribute(ctx, req interface{}) *gom
}
// GetPieces mocks base method.
func (m *MockManager) GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (m *MockManager) GetPieces(ctx context.Context, req *v1.PieceTaskRequest) (*v1.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPieces", ctx, req)
ret0, _ := ret[0].(*base.PiecePacket)
ret0, _ := ret[0].(*v1.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}

11
client/daemon/storage/storage_manager.go
View File

@ -38,11 +38,12 @@ import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/trace"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/gc"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
type TaskStorageDriver interface {
@ -56,11 +57,11 @@ type TaskStorageDriver interface {
ReadAllPieces(ctx context.Context, req *ReadAllPiecesRequest) (io.ReadCloser, error)
GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error)
GetPieces(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error)
GetTotalPieces(ctx context.Context, req *PeerTaskMetadata) (int32, error)
GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*base.ExtendAttribute, error)
GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*commonv1.ExtendAttribute, error)
UpdateTask(ctx context.Context, req *UpdateTaskRequest) error
@ -316,7 +317,7 @@ func (s *storageManager) Store(ctx context.Context, req *StoreRequest) error {
return t.Store(ctx, req)
}
func (s *storageManager) GetPieces(ctx context.Context, req *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (s *storageManager) GetPieces(ctx context.Context, req *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
t, ok := s.LoadTask(
PeerTaskMetadata{
TaskID: req.TaskId,
@ -340,7 +341,7 @@ func (s *storageManager) GetTotalPieces(ctx context.Context, req *PeerTaskMetada
return t.(TaskStorageDriver).GetTotalPieces(ctx, req)
}
func (s *storageManager) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*base.ExtendAttribute, error) {
func (s *storageManager) GetExtendAttribute(ctx context.Context, req *PeerTaskMetadata) (*commonv1.ExtendAttribute, error) {
t, ok := s.LoadTask(
PeerTaskMetadata{
TaskID: req.TaskID,

13
client/daemon/transport/transport.go
View File

@ -35,14 +35,15 @@ import (
"go.opentelemetry.io/otel/propagation"
"google.golang.org/grpc/status"
commonv1 "d7y.io/api/pkg/apis/common/v1"
errordetailsv1 "d7y.io/api/pkg/apis/errordetails/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/client/daemon/metrics"
"d7y.io/dragonfly/v2/client/daemon/peer"
"d7y.io/dragonfly/v2/client/util"
logger "d7y.io/dragonfly/v2/internal/dflog"
nethttp "d7y.io/dragonfly/v2/pkg/net/http"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/errordetails"
)
var _ *logger.SugaredLoggerOnWith // pin this package for no log code generation
@ -70,7 +71,7 @@ type transport struct {
defaultFilter string
// defaultFilter is used for registering steam task
defaultPattern base.Pattern
defaultPattern commonv1.Pattern
// defaultTag is used when http request without X-Dragonfly-Tag Header
defaultTag string
@ -125,7 +126,7 @@ func WithDefaultFilter(f string) Option {
}
// WithDefaultPattern sets default pattern
func WithDefaultPattern(pattern base.Pattern) Option {
func WithDefaultPattern(pattern commonv1.Pattern) Option {
return func(rt *transport) *transport {
rt.defaultPattern = pattern
return rt
@ -215,7 +216,7 @@ func (rt *transport) download(ctx context.Context, req *http.Request) (*http.Res
log.Infof("start download with url: %s", url)
// Init meta value
meta := &base.UrlMeta{Header: map[string]string{}}
meta := &commonv1.UrlMeta{Header: map[string]string{}}
var rg *util.Range
// Set meta range's value
@ -261,7 +262,7 @@ func (rt *transport) download(ctx context.Context, req *http.Request) (*http.Res
if st, ok := status.FromError(err); ok {
for _, detail := range st.Details() {
switch d := detail.(type) {
case *errordetails.SourceError:
case *errordetailsv1.SourceError:
hdr := nethttp.MapToHeader(attr)
for k, v := range d.Metadata.Header {
hdr.Set(k, v)

35
client/dfcache/dfcache.go
View File

@ -24,12 +24,13 @@ import (
"os"
"time"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
"d7y.io/dragonfly/v2/client/config"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/basic"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
daemonclient "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
)
@ -89,7 +90,7 @@ func statTask(ctx context.Context, client daemonclient.DaemonClient, cfg *config
}
// Task not found, return os.ErrNotExist
if dferrors.CheckError(statError, base.Code_PeerTaskNotFound) {
if dferrors.CheckError(statError, commonv1.Code_PeerTaskNotFound) {
return os.ErrNotExist
}
@ -98,10 +99,10 @@ func statTask(ctx context.Context, client daemonclient.DaemonClient, cfg *config
return statError
}
func newStatRequest(cfg *config.DfcacheConfig) *dfdaemon.StatTaskRequest {
return &dfdaemon.StatTaskRequest{
func newStatRequest(cfg *config.DfcacheConfig) *dfdaemonv1.StatTaskRequest {
return &dfdaemonv1.StatTaskRequest{
Url: newCid(cfg.Cid),
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: cfg.Tag,
},
LocalOnly: cfg.LocalOnly,
@ -158,12 +159,12 @@ func importTask(ctx context.Context, client daemonclient.DaemonClient, cfg *conf
return nil
}
func newImportRequest(cfg *config.DfcacheConfig) *dfdaemon.ImportTaskRequest {
return &dfdaemon.ImportTaskRequest{
Type: base.TaskType_DfCache,
func newImportRequest(cfg *config.DfcacheConfig) *dfdaemonv1.ImportTaskRequest {
return &dfdaemonv1.ImportTaskRequest{
Type: commonv1.TaskType_DfCache,
Url: newCid(cfg.Cid),
Path: cfg.Path,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: cfg.Tag,
},
}
@ -217,7 +218,7 @@ func exportTask(ctx context.Context, client daemonclient.DaemonClient, cfg *conf
}
// Task not found, return os.ErrNotExist
if dferrors.CheckError(exportError, base.Code_PeerTaskNotFound) {
if dferrors.CheckError(exportError, commonv1.Code_PeerTaskNotFound) {
return os.ErrNotExist
}
@ -226,13 +227,13 @@ func exportTask(ctx context.Context, client daemonclient.DaemonClient, cfg *conf
return exportError
}
func newExportRequest(cfg *config.DfcacheConfig) *dfdaemon.ExportTaskRequest {
return &dfdaemon.ExportTaskRequest{
func newExportRequest(cfg *config.DfcacheConfig) *dfdaemonv1.ExportTaskRequest {
return &dfdaemonv1.ExportTaskRequest{
Url: newCid(cfg.Cid),
Output: cfg.Output,
Timeout: uint64(cfg.Timeout),
Limit: float64(cfg.RateLimit),
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: cfg.Tag,
},
Uid: int64(basic.UserID),
@ -290,10 +291,10 @@ func deleteTask(ctx context.Context, client daemonclient.DaemonClient, cfg *conf
return nil
}
func newDeleteRequest(cfg *config.DfcacheConfig) *dfdaemon.DeleteTaskRequest {
return &dfdaemon.DeleteTaskRequest{
func newDeleteRequest(cfg *config.DfcacheConfig) *dfdaemonv1.DeleteTaskRequest {
return &dfdaemonv1.DeleteTaskRequest{
Url: newCid(cfg.Cid),
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Tag: cfg.Tag,
},
}

13
client/dfget/dfget.go
View File

@ -33,12 +33,13 @@ import (
"github.com/go-http-utils/headers"
"github.com/schollz/progressbar/v3"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
"d7y.io/dragonfly/v2/client/config"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/basic"
"d7y.io/dragonfly/v2/pkg/digest"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
daemonclient "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
"d7y.io/dragonfly/v2/pkg/source"
pkgstrings "d7y.io/dragonfly/v2/pkg/strings"
@ -91,7 +92,7 @@ func singleDownload(ctx context.Context, client daemonclient.DaemonClient, cfg *
var (
start = time.Now()
stream *daemonclient.DownResultStream
result *dfdaemon.DownResult
result *dfdaemonv1.DownResult
pb *progressbar.ProgressBar
request = newDownRequest(cfg, hdr)
downError error
@ -220,20 +221,20 @@ func parseHeader(s []string) map[string]string {
return hdr
}
func newDownRequest(cfg *config.DfgetConfig, hdr map[string]string) *dfdaemon.DownRequest {
func newDownRequest(cfg *config.DfgetConfig, hdr map[string]string) *dfdaemonv1.DownRequest {
var rg string
if r, ok := hdr[headers.Range]; ok {
rg = strings.TrimLeft(r, "bytes=")
} else {
rg = cfg.Range
}
return &dfdaemon.DownRequest{
return &dfdaemonv1.DownRequest{
Url: cfg.URL,
Output: cfg.Output,
Timeout: uint64(cfg.Timeout),
Limit: float64(cfg.RateLimit.Limit),
DisableBackSource: cfg.DisableBackSource,
UrlMeta: &base.UrlMeta{
UrlMeta: &commonv1.UrlMeta{
Digest: cfg.Digest,
Tag: cfg.Tag,
Range: rg,

2
cmd/dfcache/cmd/root.go
View File

@ -50,7 +50,7 @@ file that has been imported or added into P2P network by other peer, it's the us
responsibility to go back to source and add file into P2P network.
`
// rootCmd represents the base command when called without any subcommands
// rootCmd represents the commonv1 command when called without any subcommands
var rootCmd = &cobra.Command{
Use: "dfcache <command> [flags]",
Short: "the P2P cache client of dragonfly",

2
cmd/dfget/cmd/root.go
View File

@ -57,7 +57,7 @@ peers to download pieces from it if it owns them. In addition, dfget has the
abilities to provide more advanced functionality, such as network bandwidth
limit, transmission encryption and so on.`
// rootCmd represents the base command when called without any subcommands
// rootCmd represents the commonv1 command when called without any subcommands
var rootCmd = &cobra.Command{
Use: "dfget url -O path",
Short: "the P2P client of dragonfly",

2
cmd/dfstore/cmd/root.go
View File

@ -43,7 +43,7 @@ Rely on S3 or OSS as the backend to ensure storage reliability.
In the process of object storage, P2P Cache is effectively used for fast read and write storage.
`
// rootCmd represents the base command when called without any subcommands
// rootCmd represents the commonv1 command when called without any subcommands
var rootCmd = &cobra.Command{
Use: "dfstore <command> [flags]",
Short: "object storage client of dragonfly.",

2
cmd/manager/cmd/root.go
View File

@ -36,7 +36,7 @@ var (
cfg *config.Config
)
// rootCmd represents the base command when called without any subcommands
// rootCmd represents the commonv1 command when called without any subcommands
var rootCmd = &cobra.Command{
Use: "manager",
Short: "The central manager of dragonfly.",

2
cmd/scheduler/cmd/root.go
View File

@ -37,7 +37,7 @@ var (
cfg *config.Config
)
// rootCmd represents the base command when called without any subcommands
// rootCmd represents the commonv1 command when called without any subcommands
var rootCmd = &cobra.Command{
Use: "scheduler",
Short: "the scheduler of dragonfly",

11
go.mod
View File

@ -3,6 +3,7 @@ module d7y.io/dragonfly/v2
go 1.18
require (
d7y.io/api v1.0.1
github.com/RichardKnop/machinery v1.10.6
github.com/Showmax/go-fqdn v1.0.0
github.com/VividCortex/mysqlerr v1.0.0
@ -16,7 +17,6 @@ require (
github.com/distribution/distribution/v3 v3.0.0-20220620080156-3e4f8a0ab147
github.com/docker/go-connections v0.4.0
github.com/docker/go-units v0.4.0
github.com/envoyproxy/protoc-gen-validate v0.6.7
github.com/gammazero/deque v0.2.0
github.com/gin-contrib/cors v1.3.1
github.com/gin-contrib/static v0.0.1
@ -70,11 +70,11 @@ require (
golang.org/x/exp v0.0.0-20220613132600-b0d781184e0d
golang.org/x/oauth2 v0.0.0-20220628200809-02e64fa58f26
golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f
golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10
golang.org/x/time v0.0.0-20220609170525-579cf78fd858
google.golang.org/api v0.90.0
google.golang.org/grpc v1.48.0
google.golang.org/protobuf v1.28.0
google.golang.org/protobuf v1.28.1
gopkg.in/natefinch/lumberjack.v2 v2.0.0
gopkg.in/yaml.v3 v3.0.1
gorm.io/driver/mysql v1.3.4
@ -102,6 +102,7 @@ require (
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/denisenkom/go-mssqldb v0.12.2 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/envoyproxy/protoc-gen-validate v0.6.7 // indirect
github.com/fsnotify/fsnotify v1.5.4 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/go-echarts/go-echarts/v2 v2.2.4 // indirect
@ -195,12 +196,12 @@ require (
go.mongodb.org/mongo-driver v1.9.1 // indirect
go.opencensus.io v0.23.0 // indirect
go.uber.org/multierr v1.8.0 // indirect
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e // indirect
golang.org/x/net v0.0.0-20220728211354-c7608f3a8462 // indirect
golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
golang.org/x/text v0.3.7 // indirect
golang.org/x/tools v0.1.11 // indirect
google.golang.org/appengine v1.6.7 // indirect
google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03 // indirect
google.golang.org/genproto v0.0.0-20220728213248-dd149ef739b9 // indirect
gopkg.in/ini.v1 v1.66.6 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
gorm.io/driver/sqlserver v1.3.2 // indirect

16
go.sum
View File

@ -69,6 +69,8 @@ cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RX
cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
d7y.io/api v1.0.1 h1:FCtyOacd7hBk3H6TFyVBLW9cAlFaS8YyQ7LPcYdrBBY=
d7y.io/api v1.0.1/go.mod h1:GFnWPZFe4DUW70aOQikRZF0pvXpbUwAsGSCAZFFitPo=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20201218220906-28db891af037/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0/go.mod h1:h6H6c8enJmmocHUbLiiGY6sx7f9i+X3m1CHdd5c6Rdw=
@ -1262,8 +1264,9 @@ golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su
golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e h1:TsQ7F31D3bUCLeqPT0u+yjp1guoArKaNKmCr22PYgTQ=
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220728211354-c7608f3a8462 h1:UreQrH7DbFXSi9ZFox6FNT3WBooWmdANpU+IfkT1T4I=
golang.org/x/net v0.0.0-20220728211354-c7608f3a8462/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@ -1403,8 +1406,8 @@ golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b h1:2n253B2r0pYSmEV+UNCQoPfU/FiaizQEK5Gu4Bq4JE8=
golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 h1:WIoqL4EROvwiPdUtaip4VcDdpZ4kha7wBWZrbVKCIZg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@ -1656,8 +1659,8 @@ google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljW
google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03 h1:W70HjnmXFJm+8RNjOpIDYW2nKsSi/af0VvIZUtYkwuU=
google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220728213248-dd149ef739b9 h1:d3fKQZK+1rWQMg3xLKQbPMirUCo29I/NRdI2WarSzTg=
google.golang.org/genproto v0.0.0-20220728213248-dd149ef739b9/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc=
google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
@ -1710,8 +1713,9 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

22
hack/protoc.sh
View File

@ -1,22 +0,0 @@
#!/bin/bash
PROTOC_ALL_IMAGE=${PROTOC_ALL_IMAGE:-"namely/protoc-all:1.47_0"}
PROTO_PATH=pkg/rpc
LANGUAGE=go
proto_modules="base cdnsystem dfdaemon manager scheduler errordetails"
echo "generate protos..."
for module in ${proto_modules}; do
if docker run --rm -v $PWD:/defs ${PROTOC_ALL_IMAGE} \
-d ${PROTO_PATH}/$module -i . \
-l ${LANGUAGE} -o . \
--go-source-relative \
--with-validator \
--validator-source-relative; then
echo "generate protos ${module} successfully"
else
echo "generate protos ${module} failed"
fi
done

10
internal/dferrors/error.go
View File

@ -20,7 +20,7 @@ import (
"errors"
"fmt"
"d7y.io/dragonfly/v2/pkg/rpc/base"
commonv1 "d7y.io/api/pkg/apis/common/v1"
)
// common and framework errors
@ -39,7 +39,7 @@ func IsEndOfStream(err error) bool {
}
type DfError struct {
Code base.Code
Code commonv1.Code
Message string
}
@ -47,21 +47,21 @@ func (s *DfError) Error() string {
return fmt.Sprintf("[%d]%s", s.Code, s.Message)
}
func New(code base.Code, msg string) *DfError {
func New(code commonv1.Code, msg string) *DfError {
return &DfError{
Code: code,
Message: msg,
}
}
func Newf(code base.Code, format string, a ...any) *DfError {
func Newf(code commonv1.Code, format string, a ...any) *DfError {
return &DfError{
Code: code,
Message: fmt.Sprintf(format, a...),
}
}
func CheckError(err error, code base.Code) bool {
func CheckError(err error, code commonv1.Code) bool {
if err == nil {
return false
}

5
manager/middlewares/error.go
View File

@ -27,8 +27,9 @@ import (
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
type ErrorResponse struct {
@ -58,7 +59,7 @@ func Error() gin.HandlerFunc {
var dferr *dferrors.DfError
if errors.As(err.Err, &dferr) {
switch dferr.Code {
case base.Code_InvalidResourceType:
case commonv1.Code_InvalidResourceType:
c.JSON(http.StatusBadRequest, ErrorResponse{
Message: http.StatusText(http.StatusBadRequest),
})

83
manager/rpcserver/rpcserver.go
View File

@ -35,6 +35,8 @@ import (
"google.golang.org/grpc/status"
"gorm.io/gorm"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/manager/cache"
"d7y.io/dragonfly/v2/manager/config"
@ -44,7 +46,6 @@ import (
"d7y.io/dragonfly/v2/manager/searcher"
"d7y.io/dragonfly/v2/manager/types"
"d7y.io/dragonfly/v2/pkg/objectstorage"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
// Default middlewares for stream.
@ -80,7 +81,7 @@ type Server struct {
// Searcher interface.
searcher searcher.Searcher
// Manager grpc interface.
manager.UnimplementedManagerServer
managerv1.UnimplementedManagerServer
// Object storage interface.
objectStorage objectstorage.ObjectStorage
// Object storage configuration.
@ -108,14 +109,14 @@ func New(
}, opts...)...)
// Register servers on grpc server.
manager.RegisterManagerServer(grpcServer, server)
managerv1.RegisterManagerServer(grpcServer, server)
healthpb.RegisterHealthServer(grpcServer, health.NewServer())
return grpcServer
}
// Get SeedPeer and SeedPeer cluster configuration.
func (s *Server) GetSeedPeer(ctx context.Context, req *manager.GetSeedPeerRequest) (*manager.SeedPeer, error) {
var pbSeedPeer manager.SeedPeer
func (s *Server) GetSeedPeer(ctx context.Context, req *managerv1.GetSeedPeerRequest) (*managerv1.SeedPeer, error) {
var pbSeedPeer managerv1.SeedPeer
cacheKey := cache.MakeSeedPeerCacheKey(uint(req.SeedPeerClusterId), req.HostName, req.Ip)
// Cache hit.
@ -143,10 +144,10 @@ func (s *Server) GetSeedPeer(ctx context.Context, req *manager.GetSeedPeerReques
}
// Construct schedulers.
var pbSchedulers []*manager.Scheduler
var pbSchedulers []*managerv1.Scheduler
for _, schedulerCluster := range seedPeer.SeedPeerCluster.SchedulerClusters {
for _, scheduler := range schedulerCluster.Schedulers {
pbSchedulers = append(pbSchedulers, &manager.Scheduler{
pbSchedulers = append(pbSchedulers, &managerv1.Scheduler{
Id: uint64(scheduler.ID),
HostName: scheduler.HostName,
Idc: scheduler.IDC,
@ -160,7 +161,7 @@ func (s *Server) GetSeedPeer(ctx context.Context, req *manager.GetSeedPeerReques
}
// Construct seed peer.
pbSeedPeer = manager.SeedPeer{
pbSeedPeer = managerv1.SeedPeer{
Id: uint64(seedPeer.ID),
Type: seedPeer.Type,
HostName: seedPeer.HostName,
@ -173,7 +174,7 @@ func (s *Server) GetSeedPeer(ctx context.Context, req *manager.GetSeedPeerReques
ObjectStoragePort: seedPeer.ObjectStoragePort,
State: seedPeer.State,
SeedPeerClusterId: uint64(seedPeer.SeedPeerClusterID),
SeedPeerCluster: &manager.SeedPeerCluster{
SeedPeerCluster: &managerv1.SeedPeerCluster{
Id: uint64(seedPeer.SeedPeerCluster.ID),
Name: seedPeer.SeedPeerCluster.Name,
Bio: seedPeer.SeedPeerCluster.BIO,
@ -196,7 +197,7 @@ func (s *Server) GetSeedPeer(ctx context.Context, req *manager.GetSeedPeerReques
}
// Update SeedPeer configuration.
func (s *Server) UpdateSeedPeer(ctx context.Context, req *manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error) {
func (s *Server) UpdateSeedPeer(ctx context.Context, req *managerv1.UpdateSeedPeerRequest) (*managerv1.SeedPeer, error) {
seedPeer := model.SeedPeer{}
if err := s.db.WithContext(ctx).First(&seedPeer, model.SeedPeer{
HostName: req.HostName,
@ -229,7 +230,7 @@ func (s *Server) UpdateSeedPeer(ctx context.Context, req *manager.UpdateSeedPeer
logger.Warnf("%s refresh keepalive status failed in seed peer cluster %d", seedPeer.HostName, seedPeer.SeedPeerClusterID)
}
return &manager.SeedPeer{
return &managerv1.SeedPeer{
Id: uint64(seedPeer.ID),
HostName: seedPeer.HostName,
Type: seedPeer.Type,
@ -246,7 +247,7 @@ func (s *Server) UpdateSeedPeer(ctx context.Context, req *manager.UpdateSeedPeer
}
// Create SeedPeer and associate cluster.
func (s *Server) createSeedPeer(ctx context.Context, req *manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error) {
func (s *Server) createSeedPeer(ctx context.Context, req *managerv1.UpdateSeedPeerRequest) (*managerv1.SeedPeer, error) {
seedPeer := model.SeedPeer{
HostName: req.HostName,
Type: req.Type,
@ -264,7 +265,7 @@ func (s *Server) createSeedPeer(ctx context.Context, req *manager.UpdateSeedPeer
return nil, status.Error(codes.Unknown, err.Error())
}
return &manager.SeedPeer{
return &managerv1.SeedPeer{
Id: uint64(seedPeer.ID),
HostName: seedPeer.HostName,
Type: seedPeer.Type,
@ -281,8 +282,8 @@ func (s *Server) createSeedPeer(ctx context.Context, req *manager.UpdateSeedPeer
}
// Get Scheduler and Scheduler cluster configuration.
func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequest) (*manager.Scheduler, error) {
var pbScheduler manager.Scheduler
func (s *Server) GetScheduler(ctx context.Context, req *managerv1.GetSchedulerRequest) (*managerv1.Scheduler, error) {
var pbScheduler managerv1.Scheduler
cacheKey := cache.MakeSchedulerCacheKey(uint(req.SchedulerClusterId), req.HostName, req.Ip)
// Cache hit.
@ -316,7 +317,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
}
// Construct seed peers.
var pbSeedPeers []*manager.SeedPeer
var pbSeedPeers []*managerv1.SeedPeer
for _, seedPeerCluster := range scheduler.SchedulerCluster.SeedPeerClusters {
seedPeerClusterConfig, err := seedPeerCluster.Config.MarshalJSON()
if err != nil {
@ -324,7 +325,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
}
for _, seedPeer := range seedPeerCluster.SeedPeers {
pbSeedPeers = append(pbSeedPeers, &manager.SeedPeer{
pbSeedPeers = append(pbSeedPeers, &managerv1.SeedPeer{
Id: uint64(seedPeer.ID),
HostName: seedPeer.HostName,
Type: seedPeer.Type,
@ -337,7 +338,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
ObjectStoragePort: seedPeer.ObjectStoragePort,
State: seedPeer.State,
SeedPeerClusterId: uint64(seedPeer.SeedPeerClusterID),
SeedPeerCluster: &manager.SeedPeerCluster{
SeedPeerCluster: &managerv1.SeedPeerCluster{
Id: uint64(seedPeerCluster.ID),
Name: seedPeerCluster.Name,
Bio: seedPeerCluster.BIO,
@ -348,7 +349,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
}
// Construct scheduler.
pbScheduler = manager.Scheduler{
pbScheduler = managerv1.Scheduler{
Id: uint64(scheduler.ID),
HostName: scheduler.HostName,
Idc: scheduler.IDC,
@ -358,7 +359,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
Port: scheduler.Port,
State: scheduler.State,
SchedulerClusterId: uint64(scheduler.SchedulerClusterID),
SchedulerCluster: &manager.SchedulerCluster{
SchedulerCluster: &managerv1.SchedulerCluster{
Id: uint64(scheduler.SchedulerCluster.ID),
Name: scheduler.SchedulerCluster.Name,
Bio: scheduler.SchedulerCluster.BIO,
@ -382,7 +383,7 @@ func (s *Server) GetScheduler(ctx context.Context, req *manager.GetSchedulerRequ
}
// Update scheduler configuration.
func (s *Server) UpdateScheduler(ctx context.Context, req *manager.UpdateSchedulerRequest) (*manager.Scheduler, error) {
func (s *Server) UpdateScheduler(ctx context.Context, req *managerv1.UpdateSchedulerRequest) (*managerv1.Scheduler, error) {
scheduler := model.Scheduler{}
if err := s.db.WithContext(ctx).First(&scheduler, model.Scheduler{
HostName: req.HostName,
@ -412,7 +413,7 @@ func (s *Server) UpdateScheduler(ctx context.Context, req *manager.UpdateSchedul
logger.Warnf("%s refresh keepalive status failed in scheduler cluster %d", scheduler.HostName, scheduler.SchedulerClusterID)
}
return &manager.Scheduler{
return &managerv1.Scheduler{
Id: uint64(scheduler.ID),
HostName: scheduler.HostName,
Idc: scheduler.IDC,
@ -426,7 +427,7 @@ func (s *Server) UpdateScheduler(ctx context.Context, req *manager.UpdateSchedul
}
// Create scheduler and associate cluster.
func (s *Server) createScheduler(ctx context.Context, req *manager.UpdateSchedulerRequest) (*manager.Scheduler, error) {
func (s *Server) createScheduler(ctx context.Context, req *managerv1.UpdateSchedulerRequest) (*managerv1.Scheduler, error) {
scheduler := model.Scheduler{
HostName: req.HostName,
IDC: req.Idc,
@ -441,7 +442,7 @@ func (s *Server) createScheduler(ctx context.Context, req *manager.UpdateSchedul
return nil, status.Error(codes.Unknown, err.Error())
}
return &manager.Scheduler{
return &managerv1.Scheduler{
Id: uint64(scheduler.ID),
HostName: scheduler.HostName,
Idc: scheduler.IDC,
@ -455,11 +456,11 @@ func (s *Server) createScheduler(ctx context.Context, req *manager.UpdateSchedul
}
// List acitve schedulers configuration.
func (s *Server) ListSchedulers(ctx context.Context, req *manager.ListSchedulersRequest) (*manager.ListSchedulersResponse, error) {
func (s *Server) ListSchedulers(ctx context.Context, req *managerv1.ListSchedulersRequest) (*managerv1.ListSchedulersResponse, error) {
log := logger.WithHostnameAndIP(req.HostName, req.Ip)
// Count the number of the active peer.
if s.config.Metrics.EnablePeerGauge && req.SourceType == manager.SourceType_PEER_SOURCE {
if s.config.Metrics.EnablePeerGauge && req.SourceType == managerv1.SourceType_PEER_SOURCE {
count, err := s.getPeerCount(ctx, req)
if err != nil {
log.Warnf("get peer count failed: %s", err.Error())
@ -468,7 +469,7 @@ func (s *Server) ListSchedulers(ctx context.Context, req *manager.ListSchedulers
}
}
var pbListSchedulersResponse manager.ListSchedulersResponse
var pbListSchedulersResponse managerv1.ListSchedulersResponse
cacheKey := cache.MakeSchedulersCacheKeyForPeer(req.HostName, req.Ip)
// Cache hit.
@ -503,10 +504,10 @@ func (s *Server) ListSchedulers(ctx context.Context, req *manager.ListSchedulers
// Construct schedulers.
for _, scheduler := range schedulers {
seedPeers := []*manager.SeedPeer{}
seedPeers := []*managerv1.SeedPeer{}
for _, seedPeerCluster := range scheduler.SchedulerCluster.SeedPeerClusters {
for _, seedPeer := range seedPeerCluster.SeedPeers {
seedPeers = append(seedPeers, &manager.SeedPeer{
seedPeers = append(seedPeers, &managerv1.SeedPeer{
Id: uint64(seedPeer.ID),
HostName: seedPeer.HostName,
Type: seedPeer.Type,
@ -523,7 +524,7 @@ func (s *Server) ListSchedulers(ctx context.Context, req *manager.ListSchedulers
}
}
pbListSchedulersResponse.Schedulers = append(pbListSchedulersResponse.Schedulers, &manager.Scheduler{
pbListSchedulersResponse.Schedulers = append(pbListSchedulersResponse.Schedulers, &managerv1.Scheduler{
Id: uint64(scheduler.ID),
HostName: scheduler.HostName,
Idc: scheduler.IDC,
@ -551,7 +552,7 @@ func (s *Server) ListSchedulers(ctx context.Context, req *manager.ListSchedulers
}
// Get the number of active peers
func (s *Server) getPeerCount(ctx context.Context, req *manager.ListSchedulersRequest) (int, error) {
func (s *Server) getPeerCount(ctx context.Context, req *managerv1.ListSchedulersRequest) (int, error) {
cacheKey := cache.MakePeerCacheKey(req.HostName, req.Ip)
if err := s.rdb.Set(ctx, cacheKey, types.Peer{
ID: cacheKey,
@ -570,7 +571,7 @@ func (s *Server) getPeerCount(ctx context.Context, req *manager.ListSchedulersRe
}
// Get object storage configuration.
func (s *Server) GetObjectStorage(ctx context.Context, req *manager.GetObjectStorageRequest) (*manager.ObjectStorage, error) {
func (s *Server) GetObjectStorage(ctx context.Context, req *managerv1.GetObjectStorageRequest) (*managerv1.ObjectStorage, error) {
log := logger.WithHostnameAndIP(req.HostName, req.Ip)
if !s.objectStorageConfig.Enable {
@ -579,7 +580,7 @@ func (s *Server) GetObjectStorage(ctx context.Context, req *manager.GetObjectSto
return nil, status.Error(codes.NotFound, msg)
}
return &manager.ObjectStorage{
return &managerv1.ObjectStorage{
Name: s.objectStorageConfig.Name,
Region: s.objectStorageConfig.Region,
Endpoint: s.objectStorageConfig.Endpoint,
@ -589,7 +590,7 @@ func (s *Server) GetObjectStorage(ctx context.Context, req *manager.GetObjectSto
}
// List buckets configuration.
func (s *Server) ListBuckets(ctx context.Context, req *manager.ListBucketsRequest) (*manager.ListBucketsResponse, error) {
func (s *Server) ListBuckets(ctx context.Context, req *managerv1.ListBucketsRequest) (*managerv1.ListBucketsResponse, error) {
log := logger.WithHostnameAndIP(req.HostName, req.Ip)
if !s.objectStorageConfig.Enable {
@ -598,7 +599,7 @@ func (s *Server) ListBuckets(ctx context.Context, req *manager.ListBucketsReques
return nil, status.Error(codes.NotFound, msg)
}
var pbListBucketsResponse manager.ListBucketsResponse
var pbListBucketsResponse managerv1.ListBucketsResponse
cacheKey := cache.MakeBucketsCacheKey(s.objectStorageConfig.Name)
// Cache hit.
@ -617,7 +618,7 @@ func (s *Server) ListBuckets(ctx context.Context, req *manager.ListBucketsReques
// Construct schedulers.
for _, bucket := range buckets {
pbListBucketsResponse.Buckets = append(pbListBucketsResponse.Buckets, &manager.Bucket{
pbListBucketsResponse.Buckets = append(pbListBucketsResponse.Buckets, &managerv1.Bucket{
Name: bucket.Name,
})
}
@ -636,7 +637,7 @@ func (s *Server) ListBuckets(ctx context.Context, req *manager.ListBucketsReques
}
// KeepAlive with manager.
func (s *Server) KeepAlive(stream manager.Manager_KeepAliveServer) error {
func (s *Server) KeepAlive(stream managerv1.Manager_KeepAliveServer) error {
req, err := stream.Recv()
if err != nil {
logger.Errorf("keepalive failed for the first time: %v", err)
@ -649,7 +650,7 @@ func (s *Server) KeepAlive(stream manager.Manager_KeepAliveServer) error {
logger.Infof("%s keepalive successfully for the first time in cluster %d", hostName, clusterID)
// Initialize active scheduler.
if sourceType == manager.SourceType_SCHEDULER_SOURCE {
if sourceType == managerv1.SourceType_SCHEDULER_SOURCE {
scheduler := model.Scheduler{}
if err := s.db.First(&scheduler, model.Scheduler{
HostName: hostName,
@ -669,7 +670,7 @@ func (s *Server) KeepAlive(stream manager.Manager_KeepAliveServer) error {
}
// Initialize active seed peer.
if sourceType == manager.SourceType_SEED_PEER_SOURCE {
if sourceType == managerv1.SourceType_SEED_PEER_SOURCE {
seedPeer := model.SeedPeer{}
if err := s.db.First(&seedPeer, model.SeedPeer{
HostName: hostName,
@ -692,7 +693,7 @@ func (s *Server) KeepAlive(stream manager.Manager_KeepAliveServer) error {
_, err := stream.Recv()
if err != nil {
// Inactive scheduler.
if sourceType == manager.SourceType_SCHEDULER_SOURCE {
if sourceType == managerv1.SourceType_SCHEDULER_SOURCE {
scheduler := model.Scheduler{}
if err := s.db.First(&scheduler, model.Scheduler{
HostName: hostName,
@ -712,7 +713,7 @@ func (s *Server) KeepAlive(stream manager.Manager_KeepAliveServer) error {
}
// Inactive seed peer.
if sourceType == manager.SourceType_SEED_PEER_SOURCE {
if sourceType == managerv1.SourceType_SEED_PEER_SOURCE {
seedPeer := model.SeedPeer{}
if err := s.db.First(&seedPeer, model.SeedPeer{
HostName: hostName,

4
manager/searcher/mocks/searcher_mock.go
View File

@ -8,8 +8,8 @@ import (
context "context"
reflect "reflect"
v1 "d7y.io/api/pkg/apis/manager/v1"
model "d7y.io/dragonfly/v2/manager/model"
manager "d7y.io/dragonfly/v2/pkg/rpc/manager"
gomock "github.com/golang/mock/gomock"
)
@ -37,7 +37,7 @@ func (m *MockSearcher) EXPECT() *MockSearcherMockRecorder {
}
// FindSchedulerClusters mocks base method.
func (m *MockSearcher) FindSchedulerClusters(arg0 context.Context, arg1 []model.SchedulerCluster, arg2 *manager.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
func (m *MockSearcher) FindSchedulerClusters(arg0 context.Context, arg1 []model.SchedulerCluster, arg2 *v1.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindSchedulerClusters", arg0, arg1, arg2)
ret0, _ := ret[0].([]model.SchedulerCluster)

7
manager/searcher/searcher.go
View File

@ -27,10 +27,11 @@ import (
"github.com/mitchellh/mapstructure"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/manager/model"
"d7y.io/dragonfly/v2/pkg/math"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
const (
@ -83,7 +84,7 @@ type Scopes struct {
type Searcher interface {
// FindSchedulerClusters finds scheduler clusters that best matches the evaluation
FindSchedulerClusters(context.Context, []model.SchedulerCluster, *manager.ListSchedulersRequest) ([]model.SchedulerCluster, error)
FindSchedulerClusters(context.Context, []model.SchedulerCluster, *managerv1.ListSchedulersRequest) ([]model.SchedulerCluster, error)
}
type searcher struct{}
@ -100,7 +101,7 @@ func New(pluginDir string) Searcher {
}
// FindSchedulerClusters finds scheduler clusters that best matches the evaluation
func (s *searcher) FindSchedulerClusters(ctx context.Context, schedulerClusters []model.SchedulerCluster, client *manager.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
func (s *searcher) FindSchedulerClusters(ctx context.Context, schedulerClusters []model.SchedulerCluster, client *managerv1.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
conditions := client.HostInfo
if len(conditions) <= 0 {
return nil, errors.New("empty conditions")

5
manager/searcher/searcher_test.go
View File

@ -22,8 +22,9 @@ import (
"github.com/stretchr/testify/assert"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
"d7y.io/dragonfly/v2/manager/model"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
func TestSchedulerCluster(t *testing.T) {
@ -730,7 +731,7 @@ func TestSchedulerCluster(t *testing.T) {
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
searcher := New(pluginDir)
clusters, ok := searcher.FindSchedulerClusters(context.Background(), tc.schedulerClusters, &manager.ListSchedulersRequest{
clusters, ok := searcher.FindSchedulerClusters(context.Background(), tc.schedulerClusters, &managerv1.ListSchedulersRequest{
HostName: "foo",
Ip: "127.0.0.1",
HostInfo: tc.conditions,

5
manager/searcher/testdata/main.go vendored
View File

@ -21,9 +21,10 @@ import (
"fmt"
"os"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
"d7y.io/dragonfly/v2/manager/model"
"d7y.io/dragonfly/v2/manager/searcher"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
func main() {
@ -33,7 +34,7 @@ func main() {
os.Exit(1)
}
clusters, err := s.FindSchedulerClusters(context.Background(), []model.SchedulerCluster{}, &manager.ListSchedulersRequest{})
clusters, err := s.FindSchedulerClusters(context.Background(), []model.SchedulerCluster{}, &managerv1.ListSchedulersRequest{})
if err != nil {
fmt.Println("scheduler cluster not found")
os.Exit(1)

5
manager/searcher/testdata/plugin/searcher.go vendored
View File

@ -19,13 +19,14 @@ package main
import (
"context"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
"d7y.io/dragonfly/v2/manager/model"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
type searcher struct{}
func (s *searcher) FindSchedulerClusters(ctx context.Context, schedulerClusters []model.SchedulerCluster, client *manager.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
func (s *searcher) FindSchedulerClusters(ctx context.Context, schedulerClusters []model.SchedulerCluster, client *managerv1.ListSchedulersRequest) ([]model.SchedulerCluster, error) {
return []model.SchedulerCluster{{Name: "foo"}}, nil
}

9
pkg/idgen/task_id.go
View File

@ -19,9 +19,10 @@ package idgen
import (
"strings"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/pkg/digest"
neturl "d7y.io/dragonfly/v2/pkg/net/url"
"d7y.io/dragonfly/v2/pkg/rpc/base"
pkgstrings "d7y.io/dragonfly/v2/pkg/strings"
)
@ -31,19 +32,19 @@ const (
// TaskID generates a task id.
// filter is separated by & character.
func TaskID(url string, meta *base.UrlMeta) string {
func TaskID(url string, meta *commonv1.UrlMeta) string {
return taskID(url, meta, false)
}
// ParentTaskID generates a task id like TaskID, but without range.
// this func is used to check the parent tasks for ranged requests
func ParentTaskID(url string, meta *base.UrlMeta) string {
func ParentTaskID(url string, meta *commonv1.UrlMeta) string {
return taskID(url, meta, true)
}
// taskID generates a task id.
// filter is separated by & character.
func taskID(url string, meta *base.UrlMeta, ignoreRange bool) string {
func taskID(url string, meta *commonv1.UrlMeta, ignoreRange bool) string {
if meta == nil {
return digest.SHA256FromStrings(url)
}

12
pkg/idgen/task_id_test.go
View File

@ -21,14 +21,14 @@ import (
"github.com/stretchr/testify/assert"
"d7y.io/dragonfly/v2/pkg/rpc/base"
commonv1 "d7y.io/api/pkg/apis/common/v1"
)
func TestTaskID(t *testing.T) {
tests := []struct {
name string
url string
meta *base.UrlMeta
meta *commonv1.UrlMeta
ignoreRange bool
expect func(t *testing.T, d any)
}{
@ -44,7 +44,7 @@ func TestTaskID(t *testing.T) {
{
name: "generate taskID with meta",
url: "https://example.com",
meta: &base.UrlMeta{
meta: &commonv1.UrlMeta{
Range: "foo",
Digest: "bar",
Tag: "",
@ -57,7 +57,7 @@ func TestTaskID(t *testing.T) {
{
name: "generate taskID with meta",
url: "https://example.com",
meta: &base.UrlMeta{
meta: &commonv1.UrlMeta{
Range: "foo",
Digest: "bar",
Tag: "",
@ -71,7 +71,7 @@ func TestTaskID(t *testing.T) {
{
name: "generate taskID with filter",
url: "https://example.com?foo=foo&bar=bar",
meta: &base.UrlMeta{
meta: &commonv1.UrlMeta{
Tag: "foo",
Filter: "foo&bar",
},
@ -83,7 +83,7 @@ func TestTaskID(t *testing.T) {
{
name: "generate taskID with tag",
url: "https://example.com",
meta: &base.UrlMeta{
meta: &commonv1.UrlMeta{
Tag: "foo",
},
expect: func(t *testing.T, d any) {

1255
pkg/rpc/base/base.pb.go
View File

File diff suppressed because it is too large Load Diff

681
pkg/rpc/base/base.pb.validate.go
View File

@ -1,681 +0,0 @@
// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pkg/rpc/base/base.proto
package base
import (
"bytes"
"errors"
"fmt"
"net"
"net/mail"
"net/url"
"regexp"
"strings"
"time"
"unicode/utf8"
"google.golang.org/protobuf/types/known/anypb"
)
// ensure the imports are used
var (
_ = bytes.MinRead
_ = errors.New("")
_ = fmt.Print
_ = utf8.UTFMax
_ = (*regexp.Regexp)(nil)
_ = (*strings.Reader)(nil)
_ = net.IPv4len
_ = time.Duration(0)
_ = (*url.URL)(nil)
_ = (*mail.Address)(nil)
_ = anypb.Any{}
)
// Validate checks the field values on GrpcDfError with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *GrpcDfError) Validate() error {
if m == nil {
return nil
}
// no validation rules for Code
// no validation rules for Message
return nil
}
// GrpcDfErrorValidationError is the validation error returned by
// GrpcDfError.Validate if the designated constraints aren't met.
type GrpcDfErrorValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e GrpcDfErrorValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e GrpcDfErrorValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e GrpcDfErrorValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e GrpcDfErrorValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e GrpcDfErrorValidationError) ErrorName() string { return "GrpcDfErrorValidationError" }
// Error satisfies the builtin error interface
func (e GrpcDfErrorValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sGrpcDfError.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = GrpcDfErrorValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = GrpcDfErrorValidationError{}
// Validate checks the field values on UrlMeta with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *UrlMeta) Validate() error {
if m == nil {
return nil
}
if m.GetDigest() != "" {
if !_UrlMeta_Digest_Pattern.MatchString(m.GetDigest()) {
return UrlMetaValidationError{
field: "Digest",
reason: "value does not match regex pattern \"^(md5)|(sha256):[A-Fa-f0-9]+$\"",
}
}
}
// no validation rules for Tag
if m.GetRange() != "" {
if !_UrlMeta_Range_Pattern.MatchString(m.GetRange()) {
return UrlMetaValidationError{
field: "Range",
reason: "value does not match regex pattern \"^[0-9]+-[0-9]*$\"",
}
}
}
// no validation rules for Filter
// no validation rules for Header
return nil
}
// UrlMetaValidationError is the validation error returned by UrlMeta.Validate
// if the designated constraints aren't met.
type UrlMetaValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e UrlMetaValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e UrlMetaValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e UrlMetaValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e UrlMetaValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e UrlMetaValidationError) ErrorName() string { return "UrlMetaValidationError" }
// Error satisfies the builtin error interface
func (e UrlMetaValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sUrlMeta.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = UrlMetaValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = UrlMetaValidationError{}
var _UrlMeta_Digest_Pattern = regexp.MustCompile("^(md5)|(sha256):[A-Fa-f0-9]+$")
var _UrlMeta_Range_Pattern = regexp.MustCompile("^[0-9]+-[0-9]*$")
// Validate checks the field values on HostLoad with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *HostLoad) Validate() error {
if m == nil {
return nil
}
if val := m.GetCpuRatio(); val < 0 || val > 1 {
return HostLoadValidationError{
field: "CpuRatio",
reason: "value must be inside range [0, 1]",
}
}
if val := m.GetMemRatio(); val < 0 || val > 1 {
return HostLoadValidationError{
field: "MemRatio",
reason: "value must be inside range [0, 1]",
}
}
if val := m.GetDiskRatio(); val < 0 || val > 1 {
return HostLoadValidationError{
field: "DiskRatio",
reason: "value must be inside range [0, 1]",
}
}
return nil
}
// HostLoadValidationError is the validation error returned by
// HostLoad.Validate if the designated constraints aren't met.
type HostLoadValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e HostLoadValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e HostLoadValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e HostLoadValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e HostLoadValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e HostLoadValidationError) ErrorName() string { return "HostLoadValidationError" }
// Error satisfies the builtin error interface
func (e HostLoadValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sHostLoad.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = HostLoadValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = HostLoadValidationError{}
// Validate checks the field values on PieceTaskRequest with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *PieceTaskRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetTaskId()) < 1 {
return PieceTaskRequestValidationError{
field: "TaskId",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetSrcPid()) < 1 {
return PieceTaskRequestValidationError{
field: "SrcPid",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetDstPid()) < 1 {
return PieceTaskRequestValidationError{
field: "DstPid",
reason: "value length must be at least 1 runes",
}
}
if m.GetStartNum() < 0 {
return PieceTaskRequestValidationError{
field: "StartNum",
reason: "value must be greater than or equal to 0",
}
}
if m.GetLimit() < 0 {
return PieceTaskRequestValidationError{
field: "Limit",
reason: "value must be greater than or equal to 0",
}
}
return nil
}
// PieceTaskRequestValidationError is the validation error returned by
// PieceTaskRequest.Validate if the designated constraints aren't met.
type PieceTaskRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e PieceTaskRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e PieceTaskRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e PieceTaskRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e PieceTaskRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e PieceTaskRequestValidationError) ErrorName() string { return "PieceTaskRequestValidationError" }
// Error satisfies the builtin error interface
func (e PieceTaskRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sPieceTaskRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = PieceTaskRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = PieceTaskRequestValidationError{}
// Validate checks the field values on PieceInfo with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *PieceInfo) Validate() error {
if m == nil {
return nil
}
// no validation rules for PieceNum
if m.GetRangeStart() < 0 {
return PieceInfoValidationError{
field: "RangeStart",
reason: "value must be greater than or equal to 0",
}
}
if m.GetRangeSize() < 0 {
return PieceInfoValidationError{
field: "RangeSize",
reason: "value must be greater than or equal to 0",
}
}
if m.GetPieceMd5() != "" {
if !_PieceInfo_PieceMd5_Pattern.MatchString(m.GetPieceMd5()) {
return PieceInfoValidationError{
field: "PieceMd5",
reason: "value does not match regex pattern \"([a-f\\\\d]{32}|[A-F\\\\d]{32}|[a-f\\\\d]{16}|[A-F\\\\d]{16})\"",
}
}
}
if m.GetPieceOffset() < 0 {
return PieceInfoValidationError{
field: "PieceOffset",
reason: "value must be greater than or equal to 0",
}
}
// no validation rules for PieceStyle
if m.GetDownloadCost() < 0 {
return PieceInfoValidationError{
field: "DownloadCost",
reason: "value must be greater than or equal to 0",
}
}
return nil
}
// PieceInfoValidationError is the validation error returned by
// PieceInfo.Validate if the designated constraints aren't met.
type PieceInfoValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e PieceInfoValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e PieceInfoValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e PieceInfoValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e PieceInfoValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e PieceInfoValidationError) ErrorName() string { return "PieceInfoValidationError" }
// Error satisfies the builtin error interface
func (e PieceInfoValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sPieceInfo.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = PieceInfoValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = PieceInfoValidationError{}
var _PieceInfo_PieceMd5_Pattern = regexp.MustCompile("([a-f\\d]{32}|[A-F\\d]{32}|[a-f\\d]{16}|[A-F\\d]{16})")
// Validate checks the field values on ExtendAttribute with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *ExtendAttribute) Validate() error {
if m == nil {
return nil
}
// no validation rules for Header
// no validation rules for StatusCode
// no validation rules for Status
return nil
}
// ExtendAttributeValidationError is the validation error returned by
// ExtendAttribute.Validate if the designated constraints aren't met.
type ExtendAttributeValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e ExtendAttributeValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e ExtendAttributeValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e ExtendAttributeValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e ExtendAttributeValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e ExtendAttributeValidationError) ErrorName() string { return "ExtendAttributeValidationError" }
// Error satisfies the builtin error interface
func (e ExtendAttributeValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sExtendAttribute.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = ExtendAttributeValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = ExtendAttributeValidationError{}
// Validate checks the field values on PiecePacket with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *PiecePacket) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetTaskId()) < 1 {
return PiecePacketValidationError{
field: "TaskId",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetDstPid()) < 1 {
return PiecePacketValidationError{
field: "DstPid",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetDstAddr()) < 1 {
return PiecePacketValidationError{
field: "DstAddr",
reason: "value length must be at least 1 runes",
}
}
for idx, item := range m.GetPieceInfos() {
_, _ = idx, item
if v, ok := interface{}(item).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return PiecePacketValidationError{
field: fmt.Sprintf("PieceInfos[%v]", idx),
reason: "embedded message failed validation",
cause: err,
}
}
}
}
// no validation rules for TotalPiece
// no validation rules for ContentLength
// no validation rules for PieceMd5Sign
if v, ok := interface{}(m.GetExtendAttribute()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return PiecePacketValidationError{
field: "ExtendAttribute",
reason: "embedded message failed validation",
cause: err,
}
}
}
return nil
}
// PiecePacketValidationError is the validation error returned by
// PiecePacket.Validate if the designated constraints aren't met.
type PiecePacketValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e PiecePacketValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e PiecePacketValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e PiecePacketValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e PiecePacketValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e PiecePacketValidationError) ErrorName() string { return "PiecePacketValidationError" }
// Error satisfies the builtin error interface
func (e PiecePacketValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sPiecePacket.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = PiecePacketValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = PiecePacketValidationError{}

185
pkg/rpc/base/base.proto
View File

@ -1,185 +0,0 @@
/*
* Copyright 2020 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package base;
import "validate/validate.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/base";
enum Code{
X_UNSPECIFIED = 0;
// success code 200-299
Success = 200;
// framework can not find server node
ServerUnavailable = 500;
// common response error 1000-1999
// client can be migrated to another scheduler/CDN
ResourceLacked = 1000;
BackToSourceAborted = 1001;
BadRequest = 1400;
PeerTaskNotFound = 1404;
UnknownError = 1500;
RequestTimeOut = 1504;
// client response error 4000-4999
ClientError = 4000;
ClientPieceRequestFail = 4001; // get piece task from other peer error
ClientScheduleTimeout = 4002; // wait scheduler response timeout
ClientContextCanceled = 4003;
ClientWaitPieceReady = 4004; // when target peer downloads from source slowly, should wait
ClientPieceDownloadFail = 4005;
ClientRequestLimitFail = 4006;
ClientConnectionError = 4007;
ClientBackSourceError = 4008;
ClientPieceNotFound = 4404;
// scheduler response error 5000-5999
SchedError = 5000;
SchedNeedBackSource = 5001; // client should try to download from source
SchedPeerGone = 5002; // client should disconnect from scheduler
SchedPeerNotFound = 5004; // peer not found in scheduler
SchedPeerPieceResultReportFail = 5005; // report piece
SchedTaskStatusError = 5006; // task status is fail
// cdnsystem response error 6000-6999
CDNTaskRegistryFail = 6001;
CDNTaskNotFound = 6404;
// manager response error 7000-7999
InvalidResourceType = 7001;
}
enum PieceStyle{
PLAIN = 0;
}
enum SizeScope{
// size > one piece size
NORMAL = 0;
// 128 byte < size <= one piece size and be plain type
SMALL = 1;
// size <= 128 byte and be plain type
TINY = 2;
}
// Pattern represents pattern of task.
enum Pattern{
// Default pattern, scheduler will use all p2p node
// include dfdaemon and seed peers.
P2P = 0;
// Seed peer pattern, scheduler will use only seed peers.
SEED_PEER = 1;
// Source pattern, scheduler will say back source
// when there is no available peer in p2p.
SOURCE = 2;
}
// TaskType represents type of task.
enum TaskType{
// Normal is normal type of task,
// normal task is a normal p2p task.
Normal = 0;
// DfCache is dfcache type of task,
// dfcache task is a cache task, and the task url is fake url.
// It can only be used for caching and cannot be downloaded back to source.
DfCache = 1;
// DfStore is dfstore type of task,
// dfstore task is a persistent task in backend.
DfStore = 2;
}
message GrpcDfError {
Code code = 1;
string message = 2;
}
// UrlMeta describes url meta info.
message UrlMeta{
// digest checks integrity of url content, for example md5:xxx or sha256:yyy
string digest = 1 [(validate.rules).string = {pattern: "^(md5)|(sha256):[A-Fa-f0-9]+$", ignore_empty:true}];
// url tag identifies different task for same url, conflict with digest
string tag = 2;
// content range for url
string range = 3 [(validate.rules).string = {pattern: "^[0-9]+-[0-9]*$", ignore_empty:true}];
// filter url used to generate task id
string filter = 4;
// other url header infos
map<string, string> header = 5;
}
message HostLoad{
// cpu usage
float cpu_ratio = 1 [(validate.rules).float = {gte: 0, lte: 1}];
// memory usage
float mem_ratio = 2 [(validate.rules).float = {gte: 0, lte: 1}];
// disk space usage
float disk_ratio = 3 [(validate.rules).float = {gte: 0, lte: 1}];
}
message PieceTaskRequest{
string task_id = 1 [(validate.rules).string.min_len = 1];
string src_pid = 2 [(validate.rules).string.min_len = 1];
string dst_pid = 3 [(validate.rules).string.min_len = 1];
// piece number
uint32 start_num = 4 [(validate.rules).uint32.gte = 0];
// expected piece count, limit = 0 represent request pieces as many shards as possible
uint32 limit = 5 [(validate.rules).uint32.gte = 0];
}
message PieceInfo{
// piece_num < 0 represent start report piece flag
int32 piece_num = 1;
uint64 range_start = 2 [(validate.rules).uint64.gte = 0];
uint32 range_size = 3 [(validate.rules).uint32.gte = 0];
string piece_md5 = 4 [(validate.rules).string = {pattern:"([a-f\\d]{32}|[A-F\\d]{32}|[a-f\\d]{16}|[A-F\\d]{16})", ignore_empty:true}];
uint64 piece_offset = 5 [(validate.rules).uint64.gte = 0];
base.PieceStyle piece_style = 6;
// total time(millisecond) consumed
uint64 download_cost = 7 [(validate.rules).uint64.gte = 0];
}
message ExtendAttribute{
// task response header, eg: HTTP Response Header
map<string, string> header = 1;
// task response code, eg: HTTP Status Code
int32 status_code = 2;
// task response status, eg: HTTP Status
string status = 3;
}
message PiecePacket{
string task_id = 2 [(validate.rules).string.min_len = 1];
string dst_pid = 3 [(validate.rules).string.min_len = 1];
// ip:port
string dst_addr = 4 [(validate.rules).string.min_len = 1];
repeated PieceInfo piece_infos = 5;
// total piece count for url, total_piece represent total piece is unknown
int32 total_piece = 6;
// content_length < 0 represent content length is unknown
int64 content_length = 7;
// sha256 code of all piece md5
string piece_md5_sign = 8;
// task extend attribute
ExtendAttribute extend_attribute = 9;
}

5
pkg/rpc/base/mocks/base_mock.go
View File

@ -1,5 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: base/base.pb.go
// Package mocks is a generated GoMock package.
package mocks

591
pkg/rpc/cdnsystem/cdnsystem.pb.go
View File

@ -1,591 +0,0 @@
//
// Copyright 2020 The Dragonfly Authors
//
// Licensed 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.28.0
// protoc v3.19.4
// source: pkg/rpc/cdnsystem/cdnsystem.proto
package cdnsystem
import (
context "context"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
_ "github.com/envoyproxy/protoc-gen-validate/validate"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type SeedRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
UrlMeta *base.UrlMeta `protobuf:"bytes,3,opt,name=url_meta,json=urlMeta,proto3" json:"url_meta,omitempty"`
}
func (x *SeedRequest) Reset() {
*x = SeedRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SeedRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SeedRequest) ProtoMessage() {}
func (x *SeedRequest) ProtoReflect() protoreflect.Message {
mi := &file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SeedRequest.ProtoReflect.Descriptor instead.
func (*SeedRequest) Descriptor() ([]byte, []int) {
return file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescGZIP(), []int{0}
}
func (x *SeedRequest) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *SeedRequest) GetUrl() string {
if x != nil {
return x.Url
}
return ""
}
func (x *SeedRequest) GetUrlMeta() *base.UrlMeta {
if x != nil {
return x.UrlMeta
}
return nil
}
// keep piece meta and data separately
// check piece md5, md5s sign and total content length
type PieceSeed struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// peer id for cdn node, need suffix with _CDN
PeerId string `protobuf:"bytes,2,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
// cdn host id
HostId string `protobuf:"bytes,3,opt,name=host_id,json=hostId,proto3" json:"host_id,omitempty"`
PieceInfo *base.PieceInfo `protobuf:"bytes,4,opt,name=piece_info,json=pieceInfo,proto3" json:"piece_info,omitempty"`
// whether or not all seeds are downloaded
Done bool `protobuf:"varint,5,opt,name=done,proto3" json:"done,omitempty"`
// content total length for the url, content_length < 0 represent content length is unknown
ContentLength int64 `protobuf:"varint,6,opt,name=content_length,json=contentLength,proto3" json:"content_length,omitempty"`
// total piece count, -1 represents task is downloading or failed
TotalPieceCount int32 `protobuf:"varint,7,opt,name=total_piece_count,json=totalPieceCount,proto3" json:"total_piece_count,omitempty"`
// begin time for the piece downloading
BeginTime uint64 `protobuf:"varint,8,opt,name=begin_time,json=beginTime,proto3" json:"begin_time,omitempty"`
// end time for the piece downloading
EndTime uint64 `protobuf:"varint,9,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
// task extend attribute
ExtendAttribute *base.ExtendAttribute `protobuf:"bytes,10,opt,name=extend_attribute,json=extendAttribute,proto3" json:"extend_attribute,omitempty"`
}
func (x *PieceSeed) Reset() {
*x = PieceSeed{}
if protoimpl.UnsafeEnabled {
mi := &file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PieceSeed) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PieceSeed) ProtoMessage() {}
func (x *PieceSeed) ProtoReflect() protoreflect.Message {
mi := &file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PieceSeed.ProtoReflect.Descriptor instead.
func (*PieceSeed) Descriptor() ([]byte, []int) {
return file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescGZIP(), []int{1}
}
func (x *PieceSeed) GetPeerId() string {
if x != nil {
return x.PeerId
}
return ""
}
func (x *PieceSeed) GetHostId() string {
if x != nil {
return x.HostId
}
return ""
}
func (x *PieceSeed) GetPieceInfo() *base.PieceInfo {
if x != nil {
return x.PieceInfo
}
return nil
}
func (x *PieceSeed) GetDone() bool {
if x != nil {
return x.Done
}
return false
}
func (x *PieceSeed) GetContentLength() int64 {
if x != nil {
return x.ContentLength
}
return 0
}
func (x *PieceSeed) GetTotalPieceCount() int32 {
if x != nil {
return x.TotalPieceCount
}
return 0
}
func (x *PieceSeed) GetBeginTime() uint64 {
if x != nil {
return x.BeginTime
}
return 0
}
func (x *PieceSeed) GetEndTime() uint64 {
if x != nil {
return x.EndTime
}
return 0
}
func (x *PieceSeed) GetExtendAttribute() *base.ExtendAttribute {
if x != nil {
return x.ExtendAttribute
}
return nil
}
var File_pkg_rpc_cdnsystem_cdnsystem_proto protoreflect.FileDescriptor
var file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDesc = []byte{
0x0a, 0x21, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73,
0x74, 0x65, 0x6d, 0x2f, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x1a, 0x17,
0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x62, 0x61, 0x73,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x22, 0x75, 0x0a, 0x0b, 0x53, 0x65, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x20, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49,
0x64, 0x12, 0x1a, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x08,
0xfa, 0x42, 0x05, 0x72, 0x03, 0x88, 0x01, 0x01, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x28, 0x0a,
0x08, 0x75, 0x72, 0x6c, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x0d, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x55, 0x72, 0x6c, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x07,
0x75, 0x72, 0x6c, 0x4d, 0x65, 0x74, 0x61, 0x22, 0xe2, 0x02, 0x0a, 0x09, 0x50, 0x69, 0x65, 0x63,
0x65, 0x53, 0x65, 0x65, 0x64, 0x12, 0x20, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52,
0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x07, 0x68, 0x6f, 0x73, 0x74, 0x5f,
0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10,
0x01, 0x52, 0x06, 0x68, 0x6f, 0x73, 0x74, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x0a, 0x70, 0x69, 0x65,
0x63, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e,
0x62, 0x61, 0x73, 0x65, 0x2e, 0x50, 0x69, 0x65, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09,
0x70, 0x69, 0x65, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x6f, 0x6e,
0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x64, 0x6f, 0x6e, 0x65, 0x12, 0x25, 0x0a,
0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18,
0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65,
0x6e, 0x67, 0x74, 0x68, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, 0x69,
0x65, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52,
0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x69, 0x65, 0x63, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74,
0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08,
0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12,
0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28,
0x04, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x10, 0x65, 0x78,
0x74, 0x65, 0x6e, 0x64, 0x5f, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x18, 0x0a,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65,
0x6e, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x0f, 0x65, 0x78, 0x74,
0x65, 0x6e, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x32, 0xc4, 0x01, 0x0a,
0x06, 0x53, 0x65, 0x65, 0x64, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x0b, 0x4f, 0x62, 0x74, 0x61, 0x69,
0x6e, 0x53, 0x65, 0x65, 0x64, 0x73, 0x12, 0x16, 0x2e, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73, 0x74,
0x65, 0x6d, 0x2e, 0x53, 0x65, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14,
0x2e, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x50, 0x69, 0x65, 0x63, 0x65,
0x53, 0x65, 0x65, 0x64, 0x30, 0x01, 0x12, 0x3a, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x50, 0x69, 0x65,
0x63, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x73, 0x12, 0x16, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x50,
0x69, 0x65, 0x63, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x11, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x50, 0x69, 0x65, 0x63, 0x65, 0x50, 0x61, 0x63, 0x6b,
0x65, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x63, 0x50, 0x69, 0x65, 0x63, 0x65, 0x54,
0x61, 0x73, 0x6b, 0x73, 0x12, 0x16, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x50, 0x69, 0x65, 0x63,
0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x62,
0x61, 0x73, 0x65, 0x2e, 0x50, 0x69, 0x65, 0x63, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x28,
0x01, 0x30, 0x01, 0x42, 0x27, 0x5a, 0x25, 0x64, 0x37, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x64, 0x72,
0x61, 0x67, 0x6f, 0x6e, 0x66, 0x6c, 0x79, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x72,
0x70, 0x63, 0x2f, 0x63, 0x64, 0x6e, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x62, 0x06, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x33,
}
var (
file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescOnce sync.Once
file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescData = file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDesc
)
func file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescGZIP() []byte {
file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescOnce.Do(func() {
file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescData = protoimpl.X.CompressGZIP(file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescData)
})
return file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDescData
}
var file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_pkg_rpc_cdnsystem_cdnsystem_proto_goTypes = []interface{}{
(*SeedRequest)(nil), // 0: cdnsystem.SeedRequest
(*PieceSeed)(nil), // 1: cdnsystem.PieceSeed
(*base.UrlMeta)(nil), // 2: base.UrlMeta
(*base.PieceInfo)(nil), // 3: base.PieceInfo
(*base.ExtendAttribute)(nil), // 4: base.ExtendAttribute
(*base.PieceTaskRequest)(nil), // 5: base.PieceTaskRequest
(*base.PiecePacket)(nil), // 6: base.PiecePacket
}
var file_pkg_rpc_cdnsystem_cdnsystem_proto_depIdxs = []int32{
2, // 0: cdnsystem.SeedRequest.url_meta:type_name -> base.UrlMeta
3, // 1: cdnsystem.PieceSeed.piece_info:type_name -> base.PieceInfo
4, // 2: cdnsystem.PieceSeed.extend_attribute:type_name -> base.ExtendAttribute
0, // 3: cdnsystem.Seeder.ObtainSeeds:input_type -> cdnsystem.SeedRequest
5, // 4: cdnsystem.Seeder.GetPieceTasks:input_type -> base.PieceTaskRequest
5, // 5: cdnsystem.Seeder.SyncPieceTasks:input_type -> base.PieceTaskRequest
1, // 6: cdnsystem.Seeder.ObtainSeeds:output_type -> cdnsystem.PieceSeed
6, // 7: cdnsystem.Seeder.GetPieceTasks:output_type -> base.PiecePacket
6, // 8: cdnsystem.Seeder.SyncPieceTasks:output_type -> base.PiecePacket
6, // [6:9] is the sub-list for method output_type
3, // [3:6] is the sub-list for method input_type
3, // [3:3] is the sub-list for extension type_name
3, // [3:3] is the sub-list for extension extendee
0, // [0:3] is the sub-list for field type_name
}
func init() { file_pkg_rpc_cdnsystem_cdnsystem_proto_init() }
func file_pkg_rpc_cdnsystem_cdnsystem_proto_init() {
if File_pkg_rpc_cdnsystem_cdnsystem_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SeedRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PieceSeed); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDesc,
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_pkg_rpc_cdnsystem_cdnsystem_proto_goTypes,
DependencyIndexes: file_pkg_rpc_cdnsystem_cdnsystem_proto_depIdxs,
MessageInfos: file_pkg_rpc_cdnsystem_cdnsystem_proto_msgTypes,
}.Build()
File_pkg_rpc_cdnsystem_cdnsystem_proto = out.File
file_pkg_rpc_cdnsystem_cdnsystem_proto_rawDesc = nil
file_pkg_rpc_cdnsystem_cdnsystem_proto_goTypes = nil
file_pkg_rpc_cdnsystem_cdnsystem_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// SeederClient is the client API for Seeder service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SeederClient interface {
// Generate seeds and return to scheduler
ObtainSeeds(ctx context.Context, in *SeedRequest, opts ...grpc.CallOption) (Seeder_ObtainSeedsClient, error)
// Get piece tasks from cdn
GetPieceTasks(ctx context.Context, in *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error)
// Sync piece tasks with other peers
SyncPieceTasks(ctx context.Context, opts ...grpc.CallOption) (Seeder_SyncPieceTasksClient, error)
}
type seederClient struct {
cc grpc.ClientConnInterface
}
func NewSeederClient(cc grpc.ClientConnInterface) SeederClient {
return &seederClient{cc}
}
func (c *seederClient) ObtainSeeds(ctx context.Context, in *SeedRequest, opts ...grpc.CallOption) (Seeder_ObtainSeedsClient, error) {
stream, err := c.cc.NewStream(ctx, &_Seeder_serviceDesc.Streams[0], "/cdnsystem.Seeder/ObtainSeeds", opts...)
if err != nil {
return nil, err
}
x := &seederObtainSeedsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Seeder_ObtainSeedsClient interface {
Recv() (*PieceSeed, error)
grpc.ClientStream
}
type seederObtainSeedsClient struct {
grpc.ClientStream
}
func (x *seederObtainSeedsClient) Recv() (*PieceSeed, error) {
m := new(PieceSeed)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *seederClient) GetPieceTasks(ctx context.Context, in *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
out := new(base.PiecePacket)
err := c.cc.Invoke(ctx, "/cdnsystem.Seeder/GetPieceTasks", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *seederClient) SyncPieceTasks(ctx context.Context, opts ...grpc.CallOption) (Seeder_SyncPieceTasksClient, error) {
stream, err := c.cc.NewStream(ctx, &_Seeder_serviceDesc.Streams[1], "/cdnsystem.Seeder/SyncPieceTasks", opts...)
if err != nil {
return nil, err
}
x := &seederSyncPieceTasksClient{stream}
return x, nil
}
type Seeder_SyncPieceTasksClient interface {
Send(*base.PieceTaskRequest) error
Recv() (*base.PiecePacket, error)
grpc.ClientStream
}
type seederSyncPieceTasksClient struct {
grpc.ClientStream
}
func (x *seederSyncPieceTasksClient) Send(m *base.PieceTaskRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *seederSyncPieceTasksClient) Recv() (*base.PiecePacket, error) {
m := new(base.PiecePacket)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// SeederServer is the server API for Seeder service.
type SeederServer interface {
// Generate seeds and return to scheduler
ObtainSeeds(*SeedRequest, Seeder_ObtainSeedsServer) error
// Get piece tasks from cdn
GetPieceTasks(context.Context, *base.PieceTaskRequest) (*base.PiecePacket, error)
// Sync piece tasks with other peers
SyncPieceTasks(Seeder_SyncPieceTasksServer) error
}
// UnimplementedSeederServer can be embedded to have forward compatible implementations.
type UnimplementedSeederServer struct {
}
func (*UnimplementedSeederServer) ObtainSeeds(*SeedRequest, Seeder_ObtainSeedsServer) error {
return status.Errorf(codes.Unimplemented, "method ObtainSeeds not implemented")
}
func (*UnimplementedSeederServer) GetPieceTasks(context.Context, *base.PieceTaskRequest) (*base.PiecePacket, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetPieceTasks not implemented")
}
func (*UnimplementedSeederServer) SyncPieceTasks(Seeder_SyncPieceTasksServer) error {
return status.Errorf(codes.Unimplemented, "method SyncPieceTasks not implemented")
}
func RegisterSeederServer(s *grpc.Server, srv SeederServer) {
s.RegisterService(&_Seeder_serviceDesc, srv)
}
func _Seeder_ObtainSeeds_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SeedRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(SeederServer).ObtainSeeds(m, &seederObtainSeedsServer{stream})
}
type Seeder_ObtainSeedsServer interface {
Send(*PieceSeed) error
grpc.ServerStream
}
type seederObtainSeedsServer struct {
grpc.ServerStream
}
func (x *seederObtainSeedsServer) Send(m *PieceSeed) error {
return x.ServerStream.SendMsg(m)
}
func _Seeder_GetPieceTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(base.PieceTaskRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SeederServer).GetPieceTasks(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/cdnsystem.Seeder/GetPieceTasks",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SeederServer).GetPieceTasks(ctx, req.(*base.PieceTaskRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Seeder_SyncPieceTasks_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(SeederServer).SyncPieceTasks(&seederSyncPieceTasksServer{stream})
}
type Seeder_SyncPieceTasksServer interface {
Send(*base.PiecePacket) error
Recv() (*base.PieceTaskRequest, error)
grpc.ServerStream
}
type seederSyncPieceTasksServer struct {
grpc.ServerStream
}
func (x *seederSyncPieceTasksServer) Send(m *base.PiecePacket) error {
return x.ServerStream.SendMsg(m)
}
func (x *seederSyncPieceTasksServer) Recv() (*base.PieceTaskRequest, error) {
m := new(base.PieceTaskRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _Seeder_serviceDesc = grpc.ServiceDesc{
ServiceName: "cdnsystem.Seeder",
HandlerType: (*SeederServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetPieceTasks",
Handler: _Seeder_GetPieceTasks_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "ObtainSeeds",
Handler: _Seeder_ObtainSeeds_Handler,
ServerStreams: true,
},
{
StreamName: "SyncPieceTasks",
Handler: _Seeder_SyncPieceTasks_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "pkg/rpc/cdnsystem/cdnsystem.proto",
}

237
pkg/rpc/cdnsystem/cdnsystem.pb.validate.go
View File

@ -1,237 +0,0 @@
// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pkg/rpc/cdnsystem/cdnsystem.proto
package cdnsystem
import (
"bytes"
"errors"
"fmt"
"net"
"net/mail"
"net/url"
"regexp"
"strings"
"time"
"unicode/utf8"
"google.golang.org/protobuf/types/known/anypb"
)
// ensure the imports are used
var (
_ = bytes.MinRead
_ = errors.New("")
_ = fmt.Print
_ = utf8.UTFMax
_ = (*regexp.Regexp)(nil)
_ = (*strings.Reader)(nil)
_ = net.IPv4len
_ = time.Duration(0)
_ = (*url.URL)(nil)
_ = (*mail.Address)(nil)
_ = anypb.Any{}
)
// Validate checks the field values on SeedRequest with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *SeedRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetTaskId()) < 1 {
return SeedRequestValidationError{
field: "TaskId",
reason: "value length must be at least 1 runes",
}
}
if uri, err := url.Parse(m.GetUrl()); err != nil {
return SeedRequestValidationError{
field: "Url",
reason: "value must be a valid URI",
cause: err,
}
} else if !uri.IsAbs() {
return SeedRequestValidationError{
field: "Url",
reason: "value must be absolute",
}
}
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return SeedRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
return nil
}
// SeedRequestValidationError is the validation error returned by
// SeedRequest.Validate if the designated constraints aren't met.
type SeedRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e SeedRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e SeedRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e SeedRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e SeedRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e SeedRequestValidationError) ErrorName() string { return "SeedRequestValidationError" }
// Error satisfies the builtin error interface
func (e SeedRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sSeedRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = SeedRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = SeedRequestValidationError{}
// Validate checks the field values on PieceSeed with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *PieceSeed) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetPeerId()) < 1 {
return PieceSeedValidationError{
field: "PeerId",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetHostId()) < 1 {
return PieceSeedValidationError{
field: "HostId",
reason: "value length must be at least 1 runes",
}
}
if v, ok := interface{}(m.GetPieceInfo()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return PieceSeedValidationError{
field: "PieceInfo",
reason: "embedded message failed validation",
cause: err,
}
}
}
// no validation rules for Done
// no validation rules for ContentLength
// no validation rules for TotalPieceCount
// no validation rules for BeginTime
// no validation rules for EndTime
if v, ok := interface{}(m.GetExtendAttribute()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return PieceSeedValidationError{
field: "ExtendAttribute",
reason: "embedded message failed validation",
cause: err,
}
}
}
return nil
}
// PieceSeedValidationError is the validation error returned by
// PieceSeed.Validate if the designated constraints aren't met.
type PieceSeedValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e PieceSeedValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e PieceSeedValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e PieceSeedValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e PieceSeedValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e PieceSeedValidationError) ErrorName() string { return "PieceSeedValidationError" }
// Error satisfies the builtin error interface
func (e PieceSeedValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sPieceSeed.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = PieceSeedValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = PieceSeedValidationError{}

63
pkg/rpc/cdnsystem/cdnsystem.proto
View File

@ -1,63 +0,0 @@
/*
* Copyright 2020 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package cdnsystem;
import "pkg/rpc/base/base.proto";
import "validate/validate.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/cdnsystem";
message SeedRequest{
string task_id = 1 [(validate.rules).string.min_len = 1];
string url = 2 [(validate.rules).string.uri = true];
base.UrlMeta url_meta = 3;
}
// keep piece meta and data separately
// check piece md5, md5s sign and total content length
message PieceSeed{
// peer id for cdn node, need suffix with _CDN
string peer_id = 2 [(validate.rules).string.min_len = 1];
// cdn host id
string host_id = 3 [(validate.rules).string.min_len = 1];
base.PieceInfo piece_info = 4;
// whether or not all seeds are downloaded
bool done = 5;
// content total length for the url, content_length < 0 represent content length is unknown
int64 content_length = 6;
// total piece count, -1 represents task is downloading or failed
int32 total_piece_count = 7;
// begin time for the piece downloading
uint64 begin_time = 8;
// end time for the piece downloading
uint64 end_time = 9;
// task extend attribute
base.ExtendAttribute extend_attribute = 10;
}
// CDN System RPC Service
service Seeder{
// Generate seeds and return to scheduler
rpc ObtainSeeds(SeedRequest)returns(stream PieceSeed);
// Get piece tasks from cdn
rpc GetPieceTasks(base.PieceTaskRequest)returns(base.PiecePacket);
// Sync piece tasks with other peers
rpc SyncPieceTasks(stream base.PieceTaskRequest)returns(stream base.PiecePacket);
}

27
pkg/rpc/cdnsystem/client/client.go
View File

@ -26,11 +26,12 @@ import (
"google.golang.org/grpc"
cdnsystemv1 "d7y.io/api/pkg/apis/cdnsystem/v1"
commonv1 "d7y.io/api/pkg/apis/common/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
)
func GetClientByAddr(addrs []dfnet.NetAddr, opts ...grpc.DialOption) CdnClient {
@ -61,13 +62,13 @@ func GetElasticClientByAddrs(addrs []dfnet.NetAddr, opts ...grpc.DialOption) (Cd
return elasticCdnClient, nil
}
// CdnClient see cdnsystem.CdnClient
// CdnClient see cdnsystemv1.CdnClient
type CdnClient interface {
ObtainSeeds(ctx context.Context, sr *cdnsystem.SeedRequest, opts ...grpc.CallOption) (*PieceSeedStream, error)
ObtainSeeds(ctx context.Context, sr *cdnsystemv1.SeedRequest, opts ...grpc.CallOption) (*PieceSeedStream, error)
GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error)
GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (*commonv1.PiecePacket, error)
SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (cdnsystem.Seeder_SyncPieceTasksClient, error)
SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (cdnsystemv1.Seeder_SyncPieceTasksClient, error)
UpdateState(addrs []dfnet.NetAddr)
@ -80,27 +81,27 @@ type cdnClient struct {
var _ CdnClient = (*cdnClient)(nil)
func (cc *cdnClient) getCdnClient(key string, stick bool) (cdnsystem.SeederClient, string, error) {
func (cc *cdnClient) getCdnClient(key string, stick bool) (cdnsystemv1.SeederClient, string, error) {
clientConn, err := cc.Connection.GetClientConn(key, stick)
if err != nil {
return nil, "", fmt.Errorf("get ClientConn for hashKey %s: %w", key, err)
}
return cdnsystem.NewSeederClient(clientConn), clientConn.Target(), nil
return cdnsystemv1.NewSeederClient(clientConn), clientConn.Target(), nil
}
func (cc *cdnClient) getSeederClientWithTarget(target string) (cdnsystem.SeederClient, error) {
func (cc *cdnClient) getSeederClientWithTarget(target string) (cdnsystemv1.SeederClient, error) {
conn, err := cc.Connection.GetClientConnByTarget(target)
if err != nil {
return nil, err
}
return cdnsystem.NewSeederClient(conn), nil
return cdnsystemv1.NewSeederClient(conn), nil
}
func (cc *cdnClient) ObtainSeeds(ctx context.Context, sr *cdnsystem.SeedRequest, opts ...grpc.CallOption) (*PieceSeedStream, error) {
func (cc *cdnClient) ObtainSeeds(ctx context.Context, sr *cdnsystemv1.SeedRequest, opts ...grpc.CallOption) (*PieceSeedStream, error) {
return newPieceSeedStream(ctx, cc, sr.TaskId, sr, opts)
}
func (cc *cdnClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
func (cc *cdnClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (*commonv1.PiecePacket, error) {
client, err := cc.getSeederClientWithTarget(addr.GetEndpoint())
if err != nil {
return nil, err
@ -108,7 +109,7 @@ func (cc *cdnClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req
return client.GetPieceTasks(ctx, req, opts...)
}
func (cc *cdnClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *base.PieceTaskRequest, opts ...grpc.CallOption) (cdnsystem.Seeder_SyncPieceTasksClient, error) {
func (cc *cdnClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (cdnsystemv1.Seeder_SyncPieceTasksClient, error) {
client, err := cc.getSeederClientWithTarget(addr.GetEndpoint())
if err != nil {
return nil, err

14
pkg/rpc/cdnsystem/client/mocks/client_mock.go
View File

@ -8,9 +8,9 @@ import (
context "context"
reflect "reflect"
v1 "d7y.io/api/pkg/apis/cdnsystem/v1"
v10 "d7y.io/api/pkg/apis/common/v1"
dfnet "d7y.io/dragonfly/v2/pkg/dfnet"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
cdnsystem "d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
client "d7y.io/dragonfly/v2/pkg/rpc/cdnsystem/client"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
@ -54,14 +54,14 @@ func (mr *MockCdnClientMockRecorder) Close() *gomock.Call {
}
// GetPieceTasks mocks base method.
func (m *MockCdnClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
func (m *MockCdnClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, req *v10.PieceTaskRequest, opts ...grpc.CallOption) (*v10.PiecePacket, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, addr, req}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPieceTasks", varargs...)
ret0, _ := ret[0].(*base.PiecePacket)
ret0, _ := ret[0].(*v10.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -74,7 +74,7 @@ func (mr *MockCdnClientMockRecorder) GetPieceTasks(ctx, addr, req interface{}, o
}
// ObtainSeeds mocks base method.
func (m *MockCdnClient) ObtainSeeds(ctx context.Context, sr *cdnsystem.SeedRequest, opts ...grpc.CallOption) (*client.PieceSeedStream, error) {
func (m *MockCdnClient) ObtainSeeds(ctx context.Context, sr *v1.SeedRequest, opts ...grpc.CallOption) (*client.PieceSeedStream, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, sr}
for _, a := range opts {
@ -94,14 +94,14 @@ func (mr *MockCdnClientMockRecorder) ObtainSeeds(ctx, sr interface{}, opts ...in
}
// SyncPieceTasks mocks base method.
func (m *MockCdnClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (cdnsystem.Seeder_SyncPieceTasksClient, error) {
func (m *MockCdnClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *v10.PieceTaskRequest, opts ...grpc.CallOption) (v1.Seeder_SyncPieceTasksClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, addr, ptr}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SyncPieceTasks", varargs...)
ret0, _ := ret[0].(cdnsystem.Seeder_SyncPieceTasksClient)
ret0, _ := ret[0].(v1.Seeder_SyncPieceTasksClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}

25
pkg/rpc/cdnsystem/client/piece_seed_stream.go
View File

@ -25,10 +25,11 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
cdnsystemv1 "d7y.io/api/pkg/apis/cdnsystem/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
)
type PieceSeedStream struct {
@ -36,16 +37,16 @@ type PieceSeedStream struct {
sc *cdnClient
ctx context.Context
hashKey string
sr *cdnsystem.SeedRequest
sr *cdnsystemv1.SeedRequest
opts []grpc.CallOption
// stream for one client
stream cdnsystem.Seeder_ObtainSeedsClient
stream cdnsystemv1.Seeder_ObtainSeedsClient
// server list which cannot serve
failedServers []string
rpc.RetryMeta
}
func newPieceSeedStream(ctx context.Context, sc *cdnClient, hashKey string, sr *cdnsystem.SeedRequest, opts []grpc.CallOption) (*PieceSeedStream, error) {
func newPieceSeedStream(ctx context.Context, sc *cdnClient, hashKey string, sr *cdnsystemv1.SeedRequest, opts []grpc.CallOption) (*PieceSeedStream, error) {
pss := &PieceSeedStream{
sc: sc,
ctx: ctx,
@ -68,7 +69,7 @@ func newPieceSeedStream(ctx context.Context, sc *cdnClient, hashKey string, sr *
func (pss *PieceSeedStream) initStream() error {
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client cdnsystem.SeederClient
var client cdnsystemv1.SeederClient
var err error
client, target, err = pss.sc.getCdnClient(pss.hashKey, false)
if err != nil {
@ -83,17 +84,17 @@ func (pss *PieceSeedStream) initStream() error {
logger.WithTaskID(pss.hashKey).Errorf("initStream: invoke cdn node %s ObtainSeeds failed: %v", target, err)
return pss.replaceClient(pss.hashKey, err)
}
pss.stream = stream.(cdnsystem.Seeder_ObtainSeedsClient)
pss.stream = stream.(cdnsystemv1.Seeder_ObtainSeedsClient)
pss.StreamTimes = 1
return nil
}
func (pss *PieceSeedStream) Recv() (ps *cdnsystem.PieceSeed, err error) {
func (pss *PieceSeedStream) Recv() (ps *cdnsystemv1.PieceSeed, err error) {
pss.sc.UpdateAccessNodeMapByHashKey(pss.hashKey)
return pss.stream.Recv()
}
func (pss *PieceSeedStream) retryRecv(cause error) (*cdnsystem.PieceSeed, error) {
func (pss *PieceSeedStream) retryRecv(cause error) (*cdnsystemv1.PieceSeed, error) {
if status.Code(cause) == codes.DeadlineExceeded || status.Code(cause) == codes.Canceled {
return nil, cause
}
@ -111,7 +112,7 @@ func (pss *PieceSeedStream) replaceStream(cause error) error {
}
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client cdnsystem.SeederClient
var client cdnsystemv1.SeederClient
var err error
client, target, err = pss.sc.getCdnClient(pss.hashKey, true)
if err != nil {
@ -123,7 +124,7 @@ func (pss *PieceSeedStream) replaceStream(cause error) error {
logger.WithTaskID(pss.hashKey).Infof("replaceStream: invoke cdn node %s ObtainSeeds failed: %v", target, err)
return pss.replaceStream(cause)
}
pss.stream = stream.(cdnsystem.Seeder_ObtainSeedsClient)
pss.stream = stream.(cdnsystemv1.Seeder_ObtainSeedsClient)
pss.StreamTimes++
return nil
}
@ -137,7 +138,7 @@ func (pss *PieceSeedStream) replaceClient(key string, cause error) error {
pss.failedServers = append(pss.failedServers, preNode)
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client cdnsystem.SeederClient
var client cdnsystemv1.SeederClient
var err error
client, target, err = pss.sc.getCdnClient(key, true)
if err != nil {
@ -149,7 +150,7 @@ func (pss *PieceSeedStream) replaceClient(key string, cause error) error {
logger.WithTaskID(pss.hashKey).Infof("replaceClient: invoke cdn node %s ObtainSeeds failed: %v", target, err)
return pss.replaceClient(key, cause)
}
pss.stream = stream.(cdnsystem.Seeder_ObtainSeedsClient)
pss.stream = stream.(cdnsystemv1.Seeder_ObtainSeedsClient)
pss.StreamTimes = 1
return nil
}

678
pkg/rpc/cdnsystem/mocks/cdnsystem_mock.go
View File

@ -1,678 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: cdnsystem/cdnsystem.pb.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
cdnsystem "d7y.io/dragonfly/v2/pkg/rpc/cdnsystem"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
metadata "google.golang.org/grpc/metadata"
)
// MockSeederClient is a mock of SeederClient interface.
type MockSeederClient struct {
ctrl *gomock.Controller
recorder *MockSeederClientMockRecorder
}
// MockSeederClientMockRecorder is the mock recorder for MockSeederClient.
type MockSeederClientMockRecorder struct {
mock *MockSeederClient
}
// NewMockSeederClient creates a new mock instance.
func NewMockSeederClient(ctrl *gomock.Controller) *MockSeederClient {
mock := &MockSeederClient{ctrl: ctrl}
mock.recorder = &MockSeederClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeederClient) EXPECT() *MockSeederClientMockRecorder {
return m.recorder
}
// GetPieceTasks mocks base method.
func (m *MockSeederClient) GetPieceTasks(ctx context.Context, in *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPieceTasks", varargs...)
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPieceTasks indicates an expected call of GetPieceTasks.
func (mr *MockSeederClientMockRecorder) GetPieceTasks(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceTasks", reflect.TypeOf((*MockSeederClient)(nil).GetPieceTasks), varargs...)
}
// ObtainSeeds mocks base method.
func (m *MockSeederClient) ObtainSeeds(ctx context.Context, in *cdnsystem.SeedRequest, opts ...grpc.CallOption) (cdnsystem.Seeder_ObtainSeedsClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ObtainSeeds", varargs...)
ret0, _ := ret[0].(cdnsystem.Seeder_ObtainSeedsClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ObtainSeeds indicates an expected call of ObtainSeeds.
func (mr *MockSeederClientMockRecorder) ObtainSeeds(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObtainSeeds", reflect.TypeOf((*MockSeederClient)(nil).ObtainSeeds), varargs...)
}
// SyncPieceTasks mocks base method.
func (m *MockSeederClient) SyncPieceTasks(ctx context.Context, opts ...grpc.CallOption) (cdnsystem.Seeder_SyncPieceTasksClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SyncPieceTasks", varargs...)
ret0, _ := ret[0].(cdnsystem.Seeder_SyncPieceTasksClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SyncPieceTasks indicates an expected call of SyncPieceTasks.
func (mr *MockSeederClientMockRecorder) SyncPieceTasks(ctx interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPieceTasks", reflect.TypeOf((*MockSeederClient)(nil).SyncPieceTasks), varargs...)
}
// MockSeeder_ObtainSeedsClient is a mock of Seeder_ObtainSeedsClient interface.
type MockSeeder_ObtainSeedsClient struct {
ctrl *gomock.Controller
recorder *MockSeeder_ObtainSeedsClientMockRecorder
}
// MockSeeder_ObtainSeedsClientMockRecorder is the mock recorder for MockSeeder_ObtainSeedsClient.
type MockSeeder_ObtainSeedsClientMockRecorder struct {
mock *MockSeeder_ObtainSeedsClient
}
// NewMockSeeder_ObtainSeedsClient creates a new mock instance.
func NewMockSeeder_ObtainSeedsClient(ctrl *gomock.Controller) *MockSeeder_ObtainSeedsClient {
mock := &MockSeeder_ObtainSeedsClient{ctrl: ctrl}
mock.recorder = &MockSeeder_ObtainSeedsClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeeder_ObtainSeedsClient) EXPECT() *MockSeeder_ObtainSeedsClientMockRecorder {
return m.recorder
}
// CloseSend mocks base method.
func (m *MockSeeder_ObtainSeedsClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockSeeder_ObtainSeedsClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).Context))
}
// Header mocks base method.
func (m *MockSeeder_ObtainSeedsClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).Header))
}
// Recv mocks base method.
func (m *MockSeeder_ObtainSeedsClient) Recv() (*cdnsystem.PieceSeed, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*cdnsystem.PieceSeed)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockSeeder_ObtainSeedsClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).RecvMsg), m)
}
// SendMsg mocks base method.
func (m_2 *MockSeeder_ObtainSeedsClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockSeeder_ObtainSeedsClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockSeeder_ObtainSeedsClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockSeeder_ObtainSeedsClient)(nil).Trailer))
}
// MockSeeder_SyncPieceTasksClient is a mock of Seeder_SyncPieceTasksClient interface.
type MockSeeder_SyncPieceTasksClient struct {
ctrl *gomock.Controller
recorder *MockSeeder_SyncPieceTasksClientMockRecorder
}
// MockSeeder_SyncPieceTasksClientMockRecorder is the mock recorder for MockSeeder_SyncPieceTasksClient.
type MockSeeder_SyncPieceTasksClientMockRecorder struct {
mock *MockSeeder_SyncPieceTasksClient
}
// NewMockSeeder_SyncPieceTasksClient creates a new mock instance.
func NewMockSeeder_SyncPieceTasksClient(ctrl *gomock.Controller) *MockSeeder_SyncPieceTasksClient {
mock := &MockSeeder_SyncPieceTasksClient{ctrl: ctrl}
mock.recorder = &MockSeeder_SyncPieceTasksClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeeder_SyncPieceTasksClient) EXPECT() *MockSeeder_SyncPieceTasksClientMockRecorder {
return m.recorder
}
// CloseSend mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).Context))
}
// Header mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).Header))
}
// Recv mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) Recv() (*base.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockSeeder_SyncPieceTasksClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) Send(arg0 *base.PieceTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).Send), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockSeeder_SyncPieceTasksClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockSeeder_SyncPieceTasksClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockSeeder_SyncPieceTasksClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockSeeder_SyncPieceTasksClient)(nil).Trailer))
}
// MockSeederServer is a mock of SeederServer interface.
type MockSeederServer struct {
ctrl *gomock.Controller
recorder *MockSeederServerMockRecorder
}
// MockSeederServerMockRecorder is the mock recorder for MockSeederServer.
type MockSeederServerMockRecorder struct {
mock *MockSeederServer
}
// NewMockSeederServer creates a new mock instance.
func NewMockSeederServer(ctrl *gomock.Controller) *MockSeederServer {
mock := &MockSeederServer{ctrl: ctrl}
mock.recorder = &MockSeederServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeederServer) EXPECT() *MockSeederServerMockRecorder {
return m.recorder
}
// GetPieceTasks mocks base method.
func (m *MockSeederServer) GetPieceTasks(arg0 context.Context, arg1 *base.PieceTaskRequest) (*base.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPieceTasks", arg0, arg1)
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPieceTasks indicates an expected call of GetPieceTasks.
func (mr *MockSeederServerMockRecorder) GetPieceTasks(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceTasks", reflect.TypeOf((*MockSeederServer)(nil).GetPieceTasks), arg0, arg1)
}
// ObtainSeeds mocks base method.
func (m *MockSeederServer) ObtainSeeds(arg0 *cdnsystem.SeedRequest, arg1 cdnsystem.Seeder_ObtainSeedsServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ObtainSeeds", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// ObtainSeeds indicates an expected call of ObtainSeeds.
func (mr *MockSeederServerMockRecorder) ObtainSeeds(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObtainSeeds", reflect.TypeOf((*MockSeederServer)(nil).ObtainSeeds), arg0, arg1)
}
// SyncPieceTasks mocks base method.
func (m *MockSeederServer) SyncPieceTasks(arg0 cdnsystem.Seeder_SyncPieceTasksServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncPieceTasks", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SyncPieceTasks indicates an expected call of SyncPieceTasks.
func (mr *MockSeederServerMockRecorder) SyncPieceTasks(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPieceTasks", reflect.TypeOf((*MockSeederServer)(nil).SyncPieceTasks), arg0)
}
// MockSeeder_ObtainSeedsServer is a mock of Seeder_ObtainSeedsServer interface.
type MockSeeder_ObtainSeedsServer struct {
ctrl *gomock.Controller
recorder *MockSeeder_ObtainSeedsServerMockRecorder
}
// MockSeeder_ObtainSeedsServerMockRecorder is the mock recorder for MockSeeder_ObtainSeedsServer.
type MockSeeder_ObtainSeedsServerMockRecorder struct {
mock *MockSeeder_ObtainSeedsServer
}
// NewMockSeeder_ObtainSeedsServer creates a new mock instance.
func NewMockSeeder_ObtainSeedsServer(ctrl *gomock.Controller) *MockSeeder_ObtainSeedsServer {
mock := &MockSeeder_ObtainSeedsServer{ctrl: ctrl}
mock.recorder = &MockSeeder_ObtainSeedsServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeeder_ObtainSeedsServer) EXPECT() *MockSeeder_ObtainSeedsServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockSeeder_ObtainSeedsServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).Context))
}
// RecvMsg mocks base method.
func (m_2 *MockSeeder_ObtainSeedsServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockSeeder_ObtainSeedsServer) Send(arg0 *cdnsystem.PieceSeed) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).Send), arg0)
}
// SendHeader mocks base method.
func (m *MockSeeder_ObtainSeedsServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockSeeder_ObtainSeedsServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockSeeder_ObtainSeedsServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockSeeder_ObtainSeedsServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockSeeder_ObtainSeedsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockSeeder_ObtainSeedsServer)(nil).SetTrailer), arg0)
}
// MockSeeder_SyncPieceTasksServer is a mock of Seeder_SyncPieceTasksServer interface.
type MockSeeder_SyncPieceTasksServer struct {
ctrl *gomock.Controller
recorder *MockSeeder_SyncPieceTasksServerMockRecorder
}
// MockSeeder_SyncPieceTasksServerMockRecorder is the mock recorder for MockSeeder_SyncPieceTasksServer.
type MockSeeder_SyncPieceTasksServerMockRecorder struct {
mock *MockSeeder_SyncPieceTasksServer
}
// NewMockSeeder_SyncPieceTasksServer creates a new mock instance.
func NewMockSeeder_SyncPieceTasksServer(ctrl *gomock.Controller) *MockSeeder_SyncPieceTasksServer {
mock := &MockSeeder_SyncPieceTasksServer{ctrl: ctrl}
mock.recorder = &MockSeeder_SyncPieceTasksServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSeeder_SyncPieceTasksServer) EXPECT() *MockSeeder_SyncPieceTasksServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).Context))
}
// Recv mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) Recv() (*base.PieceTaskRequest, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*base.PieceTaskRequest)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockSeeder_SyncPieceTasksServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) Send(arg0 *base.PiecePacket) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).Send), arg0)
}
// SendHeader mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockSeeder_SyncPieceTasksServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockSeeder_SyncPieceTasksServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockSeeder_SyncPieceTasksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockSeeder_SyncPieceTasksServer)(nil).SetTrailer), arg0)
}

5
pkg/rpc/client.go
View File

@ -30,10 +30,11 @@ import (
"google.golang.org/grpc/status"
"k8s.io/apimachinery/pkg/util/sets"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
const (
@ -371,7 +372,7 @@ func (conn *Connection) TryMigrate(key string, cause error, exclusiveNodes []str
}
// TODO recover findCandidateClientConn error
if e, ok := cause.(*dferrors.DfError); ok {
if e.Code != base.Code_ResourceLacked {
if e.Code != commonv1.Code_ResourceLacked {
return "", cause
}
}

5
pkg/rpc/client_util.go
View File

@ -28,10 +28,11 @@ import (
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
commonv1 "d7y.io/api/pkg/apis/common/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/math"
"d7y.io/dragonfly/v2/pkg/rpc/base"
)
const (
@ -195,7 +196,7 @@ func convertClientError(err error) error {
s := status.Convert(err)
for _, d := range s.Details() {
switch internal := d.(type) {
case *base.GrpcDfError:
case *commonv1.GrpcDfError:
return &dferrors.DfError{
Code: internal.Code,
Message: internal.Message,

18
pkg/rpc/base/common/common.go → pkg/rpc/common/common.go
View File

@ -1,5 +1,5 @@
/*
* Copyright 2020 The Dragonfly Authors
* Copyright 2022 The Dragonfly Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -22,14 +22,14 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"d7y.io/dragonfly/v2/pkg/rpc/base"
commonv1 "d7y.io/api/pkg/apis/common/v1"
)
var EndOfPiece = int32(1) << 30
var BeginOfPiece = int32(-1)
func NewGrpcDfError(code base.Code, msg string) *base.GrpcDfError {
return &base.GrpcDfError{
func NewGrpcDfError(code commonv1.Code, msg string) *commonv1.GrpcDfError {
return &commonv1.GrpcDfError{
Code: code,
Message: msg,
}
@ -37,7 +37,7 @@ func NewGrpcDfError(code base.Code, msg string) *base.GrpcDfError {
// NewResWithCodeAndMsg returns a response ptr with code and msg,
// ptr is a expected type ptr.
func NewResWithCodeAndMsg(ptr any, code base.Code, msg string) any {
func NewResWithCodeAndMsg(ptr any, code commonv1.Code, msg string) any {
typ := reflect.TypeOf(ptr)
v := reflect.New(typ.Elem())
@ -46,14 +46,14 @@ func NewResWithCodeAndMsg(ptr any, code base.Code, msg string) any {
func NewResWithErr(ptr any, err error) any {
st := status.Convert(err)
var code base.Code
var code commonv1.Code
switch st.Code() {
case codes.DeadlineExceeded:
code = base.Code_RequestTimeOut
code = commonv1.Code_RequestTimeOut
case codes.OK:
code = base.Code_Success
code = commonv1.Code_Success
default:
code = base.Code_UnknownError
code = commonv1.Code_UnknownError
}
return NewResWithCodeAndMsg(ptr, code, st.Message())
}

43
pkg/rpc/dfdaemon/client/client.go
View File

@ -29,12 +29,13 @@ import (
"google.golang.org/grpc"
"google.golang.org/protobuf/types/known/emptypb"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/idgen"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
)
var _ DaemonClient = (*daemonClient)(nil)
@ -76,23 +77,23 @@ func GetElasticClientByAddrs(addrs []dfnet.NetAddr, opts ...grpc.DialOption) (Da
return elasticDaemonClient, nil
}
// DaemonClient see dfdaemon.DaemonClient
// DaemonClient see dfdaemonv1.DaemonClient
type DaemonClient interface {
Download(ctx context.Context, req *dfdaemon.DownRequest, opts ...grpc.CallOption) (*DownResultStream, error)
Download(ctx context.Context, req *dfdaemonv1.DownRequest, opts ...grpc.CallOption) (*DownResultStream, error)
GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error)
GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (*commonv1.PiecePacket, error)
SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (dfdaemon.Daemon_SyncPieceTasksClient, error)
SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (dfdaemonv1.Daemon_SyncPieceTasksClient, error)
CheckHealth(ctx context.Context, target dfnet.NetAddr, opts ...grpc.CallOption) error
StatTask(ctx context.Context, req *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) error
StatTask(ctx context.Context, req *dfdaemonv1.StatTaskRequest, opts ...grpc.CallOption) error
ImportTask(ctx context.Context, req *dfdaemon.ImportTaskRequest, opts ...grpc.CallOption) error
ImportTask(ctx context.Context, req *dfdaemonv1.ImportTaskRequest, opts ...grpc.CallOption) error
ExportTask(ctx context.Context, req *dfdaemon.ExportTaskRequest, opts ...grpc.CallOption) error
ExportTask(ctx context.Context, req *dfdaemonv1.ExportTaskRequest, opts ...grpc.CallOption) error
DeleteTask(ctx context.Context, req *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) error
DeleteTask(ctx context.Context, req *dfdaemonv1.DeleteTaskRequest, opts ...grpc.CallOption) error
Close() error
}
@ -101,30 +102,30 @@ type daemonClient struct {
*rpc.Connection
}
func (dc *daemonClient) getDaemonClient(key string, stick bool) (dfdaemon.DaemonClient, string, error) {
func (dc *daemonClient) getDaemonClient(key string, stick bool) (dfdaemonv1.DaemonClient, string, error) {
clientConn, err := dc.Connection.GetClientConn(key, stick)
if err != nil {
return nil, "", err
}
return dfdaemon.NewDaemonClient(clientConn), clientConn.Target(), nil
return dfdaemonv1.NewDaemonClient(clientConn), clientConn.Target(), nil
}
func (dc *daemonClient) getDaemonClientWithTarget(target string) (dfdaemon.DaemonClient, error) {
func (dc *daemonClient) getDaemonClientWithTarget(target string) (dfdaemonv1.DaemonClient, error) {
conn, err := dc.Connection.GetClientConnByTarget(target)
if err != nil {
return nil, err
}
return dfdaemon.NewDaemonClient(conn), nil
return dfdaemonv1.NewDaemonClient(conn), nil
}
func (dc *daemonClient) Download(ctx context.Context, req *dfdaemon.DownRequest, opts ...grpc.CallOption) (*DownResultStream, error) {
func (dc *daemonClient) Download(ctx context.Context, req *dfdaemonv1.DownRequest, opts ...grpc.CallOption) (*DownResultStream, error) {
req.Uuid = uuid.New().String()
// generate taskID
taskID := idgen.TaskID(req.Url, req.UrlMeta)
return newDownResultStream(ctx, dc, taskID, req, opts)
}
func (dc *daemonClient) GetPieceTasks(ctx context.Context, target dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket,
func (dc *daemonClient) GetPieceTasks(ctx context.Context, target dfnet.NetAddr, ptr *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (*commonv1.PiecePacket,
error) {
client, err := dc.getDaemonClientWithTarget(target.GetEndpoint())
if err != nil {
@ -133,7 +134,7 @@ func (dc *daemonClient) GetPieceTasks(ctx context.Context, target dfnet.NetAddr,
return client.GetPieceTasks(ctx, ptr, opts...)
}
func (dc *daemonClient) SyncPieceTasks(ctx context.Context, target dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (dfdaemon.Daemon_SyncPieceTasksClient, error) {
func (dc *daemonClient) SyncPieceTasks(ctx context.Context, target dfnet.NetAddr, ptr *commonv1.PieceTaskRequest, opts ...grpc.CallOption) (dfdaemonv1.Daemon_SyncPieceTasksClient, error) {
client, err := dc.getDaemonClientWithTarget(target.GetEndpoint())
if err != nil {
return nil, err
@ -162,7 +163,7 @@ func (dc *daemonClient) CheckHealth(ctx context.Context, target dfnet.NetAddr, o
return
}
func (dc *daemonClient) StatTask(ctx context.Context, req *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) error {
func (dc *daemonClient) StatTask(ctx context.Context, req *dfdaemonv1.StatTaskRequest, opts ...grpc.CallOption) error {
// StatTask is a latency sensitive operation, so we don't retry & wait for daemon to start,
// we assume daemon is already running.
taskID := idgen.TaskID(req.Url, req.UrlMeta)
@ -175,7 +176,7 @@ func (dc *daemonClient) StatTask(ctx context.Context, req *dfdaemon.StatTaskRequ
return err
}
func (dc *daemonClient) ImportTask(ctx context.Context, req *dfdaemon.ImportTaskRequest, opts ...grpc.CallOption) error {
func (dc *daemonClient) ImportTask(ctx context.Context, req *dfdaemonv1.ImportTaskRequest, opts ...grpc.CallOption) error {
taskID := idgen.TaskID(req.Url, req.UrlMeta)
client, _, err := dc.getDaemonClient(taskID, false)
if err != nil {
@ -185,7 +186,7 @@ func (dc *daemonClient) ImportTask(ctx context.Context, req *dfdaemon.ImportTask
return err
}
func (dc *daemonClient) ExportTask(ctx context.Context, req *dfdaemon.ExportTaskRequest, opts ...grpc.CallOption) error {
func (dc *daemonClient) ExportTask(ctx context.Context, req *dfdaemonv1.ExportTaskRequest, opts ...grpc.CallOption) error {
taskID := idgen.TaskID(req.Url, req.UrlMeta)
client, _, err := dc.getDaemonClient(taskID, false)
if err != nil {
@ -195,7 +196,7 @@ func (dc *daemonClient) ExportTask(ctx context.Context, req *dfdaemon.ExportTask
return err
}
func (dc *daemonClient) DeleteTask(ctx context.Context, req *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) error {
func (dc *daemonClient) DeleteTask(ctx context.Context, req *dfdaemonv1.DeleteTaskRequest, opts ...grpc.CallOption) error {
taskID := idgen.TaskID(req.Url, req.UrlMeta)
client, _, err := dc.getDaemonClient(taskID, false)
if err != nil {

25
pkg/rpc/dfdaemon/client/down_result_stream.go
View File

@ -25,25 +25,26 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
)
type DownResultStream struct {
dc *daemonClient
ctx context.Context
hashKey string
req *dfdaemon.DownRequest
req *dfdaemonv1.DownRequest
opts []grpc.CallOption
// stream for one client
stream dfdaemon.Daemon_DownloadClient
stream dfdaemonv1.Daemon_DownloadClient
failedServers []string
rpc.RetryMeta
}
func newDownResultStream(ctx context.Context, dc *daemonClient, hashKey string, req *dfdaemon.DownRequest, opts []grpc.CallOption) (*DownResultStream, error) {
func newDownResultStream(ctx context.Context, dc *daemonClient, hashKey string, req *dfdaemonv1.DownRequest, opts []grpc.CallOption) (*DownResultStream, error) {
drs := &DownResultStream{
dc: dc,
ctx: ctx,
@ -67,7 +68,7 @@ func newDownResultStream(ctx context.Context, dc *daemonClient, hashKey string,
func (drs *DownResultStream) initStream() error {
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client dfdaemon.DaemonClient
var client dfdaemonv1.DaemonClient
var err error
client, target, err = drs.dc.getDaemonClient(drs.hashKey, false)
if err != nil {
@ -82,12 +83,12 @@ func (drs *DownResultStream) initStream() error {
logger.WithTaskID(drs.hashKey).Infof("initStream: invoke daemon node %s Download failed: %v", target, err)
return drs.replaceClient(err)
}
drs.stream = stream.(dfdaemon.Daemon_DownloadClient)
drs.stream = stream.(dfdaemonv1.Daemon_DownloadClient)
drs.StreamTimes = 1
return nil
}
func (drs *DownResultStream) Recv() (dr *dfdaemon.DownResult, err error) {
func (drs *DownResultStream) Recv() (dr *dfdaemonv1.DownResult, err error) {
defer func() {
if dr != nil {
if dr.TaskId != drs.hashKey {
@ -101,7 +102,7 @@ func (drs *DownResultStream) Recv() (dr *dfdaemon.DownResult, err error) {
return drs.stream.Recv()
}
func (drs *DownResultStream) retryRecv(cause error) (*dfdaemon.DownResult, error) {
func (drs *DownResultStream) retryRecv(cause error) (*dfdaemonv1.DownResult, error) {
if status.Code(cause) == codes.DeadlineExceeded || status.Code(cause) == codes.Canceled {
return nil, cause
}
@ -120,7 +121,7 @@ func (drs *DownResultStream) replaceStream(cause error) error {
}
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client dfdaemon.DaemonClient
var client dfdaemonv1.DaemonClient
var err error
client, target, err = drs.dc.getDaemonClient(drs.hashKey, true)
if err != nil {
@ -132,7 +133,7 @@ func (drs *DownResultStream) replaceStream(cause error) error {
logger.WithTaskID(drs.hashKey).Infof("replaceStream: invoke daemon node %s Download failed: %v", target, err)
return drs.replaceClient(cause)
}
drs.stream = stream.(dfdaemon.Daemon_DownloadClient)
drs.stream = stream.(dfdaemonv1.Daemon_DownloadClient)
drs.StreamTimes++
return nil
}
@ -147,7 +148,7 @@ func (drs *DownResultStream) replaceClient(cause error) error {
var target string
stream, err := rpc.ExecuteWithRetry(func() (any, error) {
var client dfdaemon.DaemonClient
var client dfdaemonv1.DaemonClient
var err error
client, target, err = drs.dc.getDaemonClient(drs.hashKey, true)
if err != nil {
@ -159,7 +160,7 @@ func (drs *DownResultStream) replaceClient(cause error) error {
logger.WithTaskID(drs.hashKey).Infof("replaceClient: invoke daemon node %s Download failed: %v", target, err)
return drs.replaceClient(cause)
}
drs.stream = stream.(dfdaemon.Daemon_DownloadClient)
drs.stream = stream.(dfdaemonv1.Daemon_DownloadClient)
drs.StreamTimes = 1
return nil
}

22
pkg/rpc/dfdaemon/client/mocks/client_mock.go
View File

@ -8,9 +8,9 @@ import (
context "context"
reflect "reflect"
v1 "d7y.io/api/pkg/apis/common/v1"
v10 "d7y.io/api/pkg/apis/dfdaemon/v1"
dfnet "d7y.io/dragonfly/v2/pkg/dfnet"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
dfdaemon "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
client "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon/client"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
@ -73,7 +73,7 @@ func (mr *MockDaemonClientMockRecorder) Close() *gomock.Call {
}
// DeleteTask mocks base method.
func (m *MockDaemonClient) DeleteTask(ctx context.Context, req *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) error {
func (m *MockDaemonClient) DeleteTask(ctx context.Context, req *v10.DeleteTaskRequest, opts ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, req}
for _, a := range opts {
@ -92,7 +92,7 @@ func (mr *MockDaemonClientMockRecorder) DeleteTask(ctx, req interface{}, opts ..
}
// Download mocks base method.
func (m *MockDaemonClient) Download(ctx context.Context, req *dfdaemon.DownRequest, opts ...grpc.CallOption) (*client.DownResultStream, error) {
func (m *MockDaemonClient) Download(ctx context.Context, req *v10.DownRequest, opts ...grpc.CallOption) (*client.DownResultStream, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, req}
for _, a := range opts {
@ -112,7 +112,7 @@ func (mr *MockDaemonClientMockRecorder) Download(ctx, req interface{}, opts ...i
}
// ExportTask mocks base method.
func (m *MockDaemonClient) ExportTask(ctx context.Context, req *dfdaemon.ExportTaskRequest, opts ...grpc.CallOption) error {
func (m *MockDaemonClient) ExportTask(ctx context.Context, req *v10.ExportTaskRequest, opts ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, req}
for _, a := range opts {
@ -131,14 +131,14 @@ func (mr *MockDaemonClientMockRecorder) ExportTask(ctx, req interface{}, opts ..
}
// GetPieceTasks mocks base method.
func (m *MockDaemonClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
func (m *MockDaemonClient) GetPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *v1.PieceTaskRequest, opts ...grpc.CallOption) (*v1.PiecePacket, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, addr, ptr}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPieceTasks", varargs...)
ret0, _ := ret[0].(*base.PiecePacket)
ret0, _ := ret[0].(*v1.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -151,7 +151,7 @@ func (mr *MockDaemonClientMockRecorder) GetPieceTasks(ctx, addr, ptr interface{}
}
// ImportTask mocks base method.
func (m *MockDaemonClient) ImportTask(ctx context.Context, req *dfdaemon.ImportTaskRequest, opts ...grpc.CallOption) error {
func (m *MockDaemonClient) ImportTask(ctx context.Context, req *v10.ImportTaskRequest, opts ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, req}
for _, a := range opts {
@ -170,7 +170,7 @@ func (mr *MockDaemonClientMockRecorder) ImportTask(ctx, req interface{}, opts ..
}
// StatTask mocks base method.
func (m *MockDaemonClient) StatTask(ctx context.Context, req *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) error {
func (m *MockDaemonClient) StatTask(ctx context.Context, req *v10.StatTaskRequest, opts ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, req}
for _, a := range opts {
@ -189,14 +189,14 @@ func (mr *MockDaemonClientMockRecorder) StatTask(ctx, req interface{}, opts ...i
}
// SyncPieceTasks mocks base method.
func (m *MockDaemonClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *base.PieceTaskRequest, opts ...grpc.CallOption) (dfdaemon.Daemon_SyncPieceTasksClient, error) {
func (m *MockDaemonClient) SyncPieceTasks(ctx context.Context, addr dfnet.NetAddr, ptr *v1.PieceTaskRequest, opts ...grpc.CallOption) (v10.Daemon_SyncPieceTasksClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, addr, ptr}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SyncPieceTasks", varargs...)
ret0, _ := ret[0].(dfdaemon.Daemon_SyncPieceTasksClient)
ret0, _ := ret[0].(v10.Daemon_SyncPieceTasksClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}

19
pkg/rpc/dfdaemon/client/peer.go
View File

@ -22,16 +22,17 @@ import (
"google.golang.org/grpc"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
)
func GetPieceTasks(ctx context.Context,
dstPeer *scheduler.PeerPacket_DestPeer,
ptr *base.PieceTaskRequest,
opts ...grpc.CallOption) (*base.PiecePacket, error) {
dstPeer *schedulerv1.PeerPacket_DestPeer,
ptr *commonv1.PieceTaskRequest,
opts ...grpc.CallOption) (*commonv1.PiecePacket, error) {
netAddr := dfnet.NetAddr{
Type: dfnet.TCP,
Addr: fmt.Sprintf("%s:%d", dstPeer.Ip, dstPeer.RpcPort),
@ -46,9 +47,9 @@ func GetPieceTasks(ctx context.Context,
}
func SyncPieceTasks(ctx context.Context,
destPeer *scheduler.PeerPacket_DestPeer,
ptr *base.PieceTaskRequest,
opts ...grpc.CallOption) (dfdaemon.Daemon_SyncPieceTasksClient, error) {
destPeer *schedulerv1.PeerPacket_DestPeer,
ptr *commonv1.PieceTaskRequest,
opts ...grpc.CallOption) (dfdaemonv1.Daemon_SyncPieceTasksClient, error) {
netAddr := dfnet.NetAddr{
Type: dfnet.TCP,
Addr: fmt.Sprintf("%s:%d", destPeer.Ip, destPeer.RpcPort),

1275
pkg/rpc/dfdaemon/dfdaemon.pb.go
View File

File diff suppressed because it is too large Load Diff

654
pkg/rpc/dfdaemon/dfdaemon.pb.validate.go
View File

@ -1,654 +0,0 @@
// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pkg/rpc/dfdaemon/dfdaemon.proto
package dfdaemon
import (
"bytes"
"errors"
"fmt"
"net"
"net/mail"
"net/url"
"regexp"
"strings"
"time"
"unicode/utf8"
"google.golang.org/protobuf/types/known/anypb"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
)
// ensure the imports are used
var (
_ = bytes.MinRead
_ = errors.New("")
_ = fmt.Print
_ = utf8.UTFMax
_ = (*regexp.Regexp)(nil)
_ = (*strings.Reader)(nil)
_ = net.IPv4len
_ = time.Duration(0)
_ = (*url.URL)(nil)
_ = (*mail.Address)(nil)
_ = anypb.Any{}
_ = base.TaskType(0)
)
// define the regex for a UUID once up-front
var _dfdaemon_uuidPattern = regexp.MustCompile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
// Validate checks the field values on DownRequest with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *DownRequest) Validate() error {
if m == nil {
return nil
}
if err := m._validateUuid(m.GetUuid()); err != nil {
return DownRequestValidationError{
field: "Uuid",
reason: "value must be a valid UUID",
cause: err,
}
}
if uri, err := url.Parse(m.GetUrl()); err != nil {
return DownRequestValidationError{
field: "Url",
reason: "value must be a valid URI",
cause: err,
}
} else if !uri.IsAbs() {
return DownRequestValidationError{
field: "Url",
reason: "value must be absolute",
}
}
if utf8.RuneCountInString(m.GetOutput()) < 1 {
return DownRequestValidationError{
field: "Output",
reason: "value length must be at least 1 runes",
}
}
if m.GetTimeout() < 0 {
return DownRequestValidationError{
field: "Timeout",
reason: "value must be greater than or equal to 0",
}
}
if m.GetLimit() < 0 {
return DownRequestValidationError{
field: "Limit",
reason: "value must be greater than or equal to 0",
}
}
// no validation rules for DisableBackSource
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return DownRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
if m.GetPattern() != "" {
if _, ok := _DownRequest_Pattern_InLookup[m.GetPattern()]; !ok {
return DownRequestValidationError{
field: "Pattern",
reason: "value must be in list [p2p seed-peer source]",
}
}
}
// no validation rules for Callsystem
// no validation rules for Uid
// no validation rules for Gid
// no validation rules for KeepOriginalOffset
return nil
}
func (m *DownRequest) _validateUuid(uuid string) error {
if matched := _dfdaemon_uuidPattern.MatchString(uuid); !matched {
return errors.New("invalid uuid format")
}
return nil
}
// DownRequestValidationError is the validation error returned by
// DownRequest.Validate if the designated constraints aren't met.
type DownRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e DownRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e DownRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e DownRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e DownRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e DownRequestValidationError) ErrorName() string { return "DownRequestValidationError" }
// Error satisfies the builtin error interface
func (e DownRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sDownRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = DownRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = DownRequestValidationError{}
var _DownRequest_Pattern_InLookup = map[string]struct{}{
"p2p": {},
"seed-peer": {},
"source": {},
}
// Validate checks the field values on DownResult with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *DownResult) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetTaskId()) < 1 {
return DownResultValidationError{
field: "TaskId",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetPeerId()) < 1 {
return DownResultValidationError{
field: "PeerId",
reason: "value length must be at least 1 runes",
}
}
if m.GetCompletedLength() < 0 {
return DownResultValidationError{
field: "CompletedLength",
reason: "value must be greater than or equal to 0",
}
}
// no validation rules for Done
return nil
}
// DownResultValidationError is the validation error returned by
// DownResult.Validate if the designated constraints aren't met.
type DownResultValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e DownResultValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e DownResultValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e DownResultValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e DownResultValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e DownResultValidationError) ErrorName() string { return "DownResultValidationError" }
// Error satisfies the builtin error interface
func (e DownResultValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sDownResult.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = DownResultValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = DownResultValidationError{}
// Validate checks the field values on StatTaskRequest with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *StatTaskRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetUrl()) < 1 {
return StatTaskRequestValidationError{
field: "Url",
reason: "value length must be at least 1 runes",
}
}
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return StatTaskRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
// no validation rules for LocalOnly
return nil
}
// StatTaskRequestValidationError is the validation error returned by
// StatTaskRequest.Validate if the designated constraints aren't met.
type StatTaskRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e StatTaskRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e StatTaskRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e StatTaskRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e StatTaskRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e StatTaskRequestValidationError) ErrorName() string { return "StatTaskRequestValidationError" }
// Error satisfies the builtin error interface
func (e StatTaskRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sStatTaskRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = StatTaskRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = StatTaskRequestValidationError{}
// Validate checks the field values on ImportTaskRequest with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *ImportTaskRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetUrl()) < 1 {
return ImportTaskRequestValidationError{
field: "Url",
reason: "value length must be at least 1 runes",
}
}
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return ImportTaskRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
if utf8.RuneCountInString(m.GetPath()) < 1 {
return ImportTaskRequestValidationError{
field: "Path",
reason: "value length must be at least 1 runes",
}
}
// no validation rules for Type
return nil
}
// ImportTaskRequestValidationError is the validation error returned by
// ImportTaskRequest.Validate if the designated constraints aren't met.
type ImportTaskRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e ImportTaskRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e ImportTaskRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e ImportTaskRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e ImportTaskRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e ImportTaskRequestValidationError) ErrorName() string {
return "ImportTaskRequestValidationError"
}
// Error satisfies the builtin error interface
func (e ImportTaskRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sImportTaskRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = ImportTaskRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = ImportTaskRequestValidationError{}
// Validate checks the field values on ExportTaskRequest with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *ExportTaskRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetUrl()) < 1 {
return ExportTaskRequestValidationError{
field: "Url",
reason: "value length must be at least 1 runes",
}
}
if utf8.RuneCountInString(m.GetOutput()) < 1 {
return ExportTaskRequestValidationError{
field: "Output",
reason: "value length must be at least 1 runes",
}
}
if m.GetTimeout() < 0 {
return ExportTaskRequestValidationError{
field: "Timeout",
reason: "value must be greater than or equal to 0",
}
}
if m.GetLimit() < 0 {
return ExportTaskRequestValidationError{
field: "Limit",
reason: "value must be greater than or equal to 0",
}
}
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return ExportTaskRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
// no validation rules for Callsystem
// no validation rules for Uid
// no validation rules for Gid
// no validation rules for LocalOnly
return nil
}
// ExportTaskRequestValidationError is the validation error returned by
// ExportTaskRequest.Validate if the designated constraints aren't met.
type ExportTaskRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e ExportTaskRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e ExportTaskRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e ExportTaskRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e ExportTaskRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e ExportTaskRequestValidationError) ErrorName() string {
return "ExportTaskRequestValidationError"
}
// Error satisfies the builtin error interface
func (e ExportTaskRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sExportTaskRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = ExportTaskRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = ExportTaskRequestValidationError{}
// Validate checks the field values on DeleteTaskRequest with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *DeleteTaskRequest) Validate() error {
if m == nil {
return nil
}
if utf8.RuneCountInString(m.GetUrl()) < 1 {
return DeleteTaskRequestValidationError{
field: "Url",
reason: "value length must be at least 1 runes",
}
}
if v, ok := interface{}(m.GetUrlMeta()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return DeleteTaskRequestValidationError{
field: "UrlMeta",
reason: "embedded message failed validation",
cause: err,
}
}
}
return nil
}
// DeleteTaskRequestValidationError is the validation error returned by
// DeleteTaskRequest.Validate if the designated constraints aren't met.
type DeleteTaskRequestValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e DeleteTaskRequestValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e DeleteTaskRequestValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e DeleteTaskRequestValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e DeleteTaskRequestValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e DeleteTaskRequestValidationError) ErrorName() string {
return "DeleteTaskRequestValidationError"
}
// Error satisfies the builtin error interface
func (e DeleteTaskRequestValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sDeleteTaskRequest.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = DeleteTaskRequestValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = DeleteTaskRequestValidationError{}

132
pkg/rpc/dfdaemon/dfdaemon.proto
View File

@ -1,132 +0,0 @@
/*
* Copyright 2020 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package dfdaemon;
import "pkg/rpc/base/base.proto";
import "google/protobuf/empty.proto";
import "validate/validate.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon";
message DownRequest{
// Identify one downloading, the framework will fill it automatically.
string uuid = 1 [(validate.rules).string.uuid = true];
// Download file from the url, not only for http.
string url = 2 [(validate.rules).string.uri = true];
// Pieces will be written to output path directly,
// at the same time, dfdaemon workspace also makes soft link to the output.
string output = 3 [(validate.rules).string.min_len = 1];
// Timeout duration.
uint64 timeout = 4 [(validate.rules).uint64.gte = 0];
// Rate limit in bytes per second.
double limit = 5 [(validate.rules).double.gte = 0];
// Disable back-to-source.
bool disable_back_source = 6;
// URL meta info.
base.UrlMeta url_meta = 7;
// Pattern has p2p/seed-peer/source, default is p2p.
string pattern = 8 [(validate.rules).string = {in:["p2p", "seed-peer", "source"], ignore_empty:true}];
// Call system.
string callsystem = 9;
// User id.
int64 uid = 10;
// Group id.
int64 gid = 11;
// Keep original offset, used for ranged request, only available for hard link, otherwise will failed.
bool keep_original_offset = 12;
}
message DownResult{
// Task id.
string task_id = 2 [(validate.rules).string.min_len = 1];
// Peer id.
string peer_id = 3 [(validate.rules).string.min_len = 1];
// Task has completed length.
uint64 completed_length = 4 [(validate.rules).uint64.gte = 0];
// Task has been completed.
bool done = 5;
}
message StatTaskRequest{
// Download url.
string url = 1 [(validate.rules).string.min_len = 1];
// URL meta info.
base.UrlMeta url_meta = 2;
// Check local cache only.
bool local_only = 3;
}
message ImportTaskRequest{
// Download url.
string url = 1 [(validate.rules).string.min_len = 1];
// URL meta info.
base.UrlMeta url_meta = 2;
// File to be imported.
string path = 3 [(validate.rules).string.min_len = 1];
// Task type.
base.TaskType type = 4;
}
message ExportTaskRequest{
// Download url.
string url = 1 [(validate.rules).string.min_len = 1];
// Output path of downloaded file.
string output = 2 [(validate.rules).string.min_len = 1];
// Timeout duration.
uint64 timeout = 3 [(validate.rules).uint64.gte = 0];
// Rate limit in bytes per second.
double limit = 4 [(validate.rules).double.gte = 0];
// URL meta info.
base.UrlMeta url_meta = 5;
// Call system.
string callsystem = 6;
// User id.
int64 uid = 7;
// Group id.
int64 gid = 8;
// Only export from local storage.
bool local_only = 9;
}
message DeleteTaskRequest{
// Download url.
string url = 1 [(validate.rules).string.min_len = 1];
// URL meta info.
base.UrlMeta url_meta = 2;
}
// Daemon Client RPC Service
service Daemon{
// Trigger client to download file
rpc Download(DownRequest) returns(stream DownResult);
// Get piece tasks from other peers
rpc GetPieceTasks(base.PieceTaskRequest)returns(base.PiecePacket);
// Check daemon health
rpc CheckHealth(google.protobuf.Empty)returns(google.protobuf.Empty);
// Sync piece tasks with other peers
rpc SyncPieceTasks(stream base.PieceTaskRequest)returns(stream base.PiecePacket);
// Check if given task exists in P2P cache system
rpc StatTask(StatTaskRequest) returns(google.protobuf.Empty);
// Import the given file into P2P cache system
rpc ImportTask(ImportTaskRequest) returns(google.protobuf.Empty);
// Export or download file from P2P cache system
rpc ExportTask(ExportTaskRequest) returns(google.protobuf.Empty);
// Delete file from P2P cache system
rpc DeleteTask(DeleteTaskRequest) returns(google.protobuf.Empty);
}

854
pkg/rpc/dfdaemon/mocks/dfdaemon_mock.go
View File

@ -1,854 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: dfdaemon/dfdaemon.pb.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
dfdaemon "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
metadata "google.golang.org/grpc/metadata"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// MockDaemonClient is a mock of DaemonClient interface.
type MockDaemonClient struct {
ctrl *gomock.Controller
recorder *MockDaemonClientMockRecorder
}
// MockDaemonClientMockRecorder is the mock recorder for MockDaemonClient.
type MockDaemonClientMockRecorder struct {
mock *MockDaemonClient
}
// NewMockDaemonClient creates a new mock instance.
func NewMockDaemonClient(ctrl *gomock.Controller) *MockDaemonClient {
mock := &MockDaemonClient{ctrl: ctrl}
mock.recorder = &MockDaemonClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemonClient) EXPECT() *MockDaemonClientMockRecorder {
return m.recorder
}
// CheckHealth mocks base method.
func (m *MockDaemonClient) CheckHealth(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CheckHealth", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CheckHealth indicates an expected call of CheckHealth.
func (mr *MockDaemonClientMockRecorder) CheckHealth(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckHealth", reflect.TypeOf((*MockDaemonClient)(nil).CheckHealth), varargs...)
}
// DeleteTask mocks base method.
func (m *MockDaemonClient) DeleteTask(ctx context.Context, in *dfdaemon.DeleteTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockDaemonClientMockRecorder) DeleteTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockDaemonClient)(nil).DeleteTask), varargs...)
}
// Download mocks base method.
func (m *MockDaemonClient) Download(ctx context.Context, in *dfdaemon.DownRequest, opts ...grpc.CallOption) (dfdaemon.Daemon_DownloadClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Download", varargs...)
ret0, _ := ret[0].(dfdaemon.Daemon_DownloadClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Download indicates an expected call of Download.
func (mr *MockDaemonClientMockRecorder) Download(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockDaemonClient)(nil).Download), varargs...)
}
// ExportTask mocks base method.
func (m *MockDaemonClient) ExportTask(ctx context.Context, in *dfdaemon.ExportTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ExportTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ExportTask indicates an expected call of ExportTask.
func (mr *MockDaemonClientMockRecorder) ExportTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTask", reflect.TypeOf((*MockDaemonClient)(nil).ExportTask), varargs...)
}
// GetPieceTasks mocks base method.
func (m *MockDaemonClient) GetPieceTasks(ctx context.Context, in *base.PieceTaskRequest, opts ...grpc.CallOption) (*base.PiecePacket, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPieceTasks", varargs...)
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPieceTasks indicates an expected call of GetPieceTasks.
func (mr *MockDaemonClientMockRecorder) GetPieceTasks(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceTasks", reflect.TypeOf((*MockDaemonClient)(nil).GetPieceTasks), varargs...)
}
// ImportTask mocks base method.
func (m *MockDaemonClient) ImportTask(ctx context.Context, in *dfdaemon.ImportTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ImportTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ImportTask indicates an expected call of ImportTask.
func (mr *MockDaemonClientMockRecorder) ImportTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTask", reflect.TypeOf((*MockDaemonClient)(nil).ImportTask), varargs...)
}
// StatTask mocks base method.
func (m *MockDaemonClient) StatTask(ctx context.Context, in *dfdaemon.StatTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "StatTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StatTask indicates an expected call of StatTask.
func (mr *MockDaemonClientMockRecorder) StatTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockDaemonClient)(nil).StatTask), varargs...)
}
// SyncPieceTasks mocks base method.
func (m *MockDaemonClient) SyncPieceTasks(ctx context.Context, opts ...grpc.CallOption) (dfdaemon.Daemon_SyncPieceTasksClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SyncPieceTasks", varargs...)
ret0, _ := ret[0].(dfdaemon.Daemon_SyncPieceTasksClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// SyncPieceTasks indicates an expected call of SyncPieceTasks.
func (mr *MockDaemonClientMockRecorder) SyncPieceTasks(ctx interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPieceTasks", reflect.TypeOf((*MockDaemonClient)(nil).SyncPieceTasks), varargs...)
}
// MockDaemon_DownloadClient is a mock of Daemon_DownloadClient interface.
type MockDaemon_DownloadClient struct {
ctrl *gomock.Controller
recorder *MockDaemon_DownloadClientMockRecorder
}
// MockDaemon_DownloadClientMockRecorder is the mock recorder for MockDaemon_DownloadClient.
type MockDaemon_DownloadClientMockRecorder struct {
mock *MockDaemon_DownloadClient
}
// NewMockDaemon_DownloadClient creates a new mock instance.
func NewMockDaemon_DownloadClient(ctrl *gomock.Controller) *MockDaemon_DownloadClient {
mock := &MockDaemon_DownloadClient{ctrl: ctrl}
mock.recorder = &MockDaemon_DownloadClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemon_DownloadClient) EXPECT() *MockDaemon_DownloadClientMockRecorder {
return m.recorder
}
// CloseSend mocks base method.
func (m *MockDaemon_DownloadClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockDaemon_DownloadClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockDaemon_DownloadClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockDaemon_DownloadClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).Context))
}
// Header mocks base method.
func (m *MockDaemon_DownloadClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockDaemon_DownloadClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).Header))
}
// Recv mocks base method.
func (m *MockDaemon_DownloadClient) Recv() (*dfdaemon.DownResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*dfdaemon.DownResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockDaemon_DownloadClientMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockDaemon_DownloadClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDaemon_DownloadClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).RecvMsg), m)
}
// SendMsg mocks base method.
func (m_2 *MockDaemon_DownloadClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockDaemon_DownloadClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockDaemon_DownloadClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockDaemon_DownloadClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDaemon_DownloadClient)(nil).Trailer))
}
// MockDaemon_SyncPieceTasksClient is a mock of Daemon_SyncPieceTasksClient interface.
type MockDaemon_SyncPieceTasksClient struct {
ctrl *gomock.Controller
recorder *MockDaemon_SyncPieceTasksClientMockRecorder
}
// MockDaemon_SyncPieceTasksClientMockRecorder is the mock recorder for MockDaemon_SyncPieceTasksClient.
type MockDaemon_SyncPieceTasksClientMockRecorder struct {
mock *MockDaemon_SyncPieceTasksClient
}
// NewMockDaemon_SyncPieceTasksClient creates a new mock instance.
func NewMockDaemon_SyncPieceTasksClient(ctrl *gomock.Controller) *MockDaemon_SyncPieceTasksClient {
mock := &MockDaemon_SyncPieceTasksClient{ctrl: ctrl}
mock.recorder = &MockDaemon_SyncPieceTasksClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemon_SyncPieceTasksClient) EXPECT() *MockDaemon_SyncPieceTasksClientMockRecorder {
return m.recorder
}
// CloseSend mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).Context))
}
// Header mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).Header))
}
// Recv mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) Recv() (*base.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockDaemon_SyncPieceTasksClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) Send(arg0 *base.PieceTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).Send), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockDaemon_SyncPieceTasksClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockDaemon_SyncPieceTasksClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockDaemon_SyncPieceTasksClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockDaemon_SyncPieceTasksClient)(nil).Trailer))
}
// MockDaemonServer is a mock of DaemonServer interface.
type MockDaemonServer struct {
ctrl *gomock.Controller
recorder *MockDaemonServerMockRecorder
}
// MockDaemonServerMockRecorder is the mock recorder for MockDaemonServer.
type MockDaemonServerMockRecorder struct {
mock *MockDaemonServer
}
// NewMockDaemonServer creates a new mock instance.
func NewMockDaemonServer(ctrl *gomock.Controller) *MockDaemonServer {
mock := &MockDaemonServer{ctrl: ctrl}
mock.recorder = &MockDaemonServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemonServer) EXPECT() *MockDaemonServerMockRecorder {
return m.recorder
}
// CheckHealth mocks base method.
func (m *MockDaemonServer) CheckHealth(arg0 context.Context, arg1 *emptypb.Empty) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CheckHealth", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CheckHealth indicates an expected call of CheckHealth.
func (mr *MockDaemonServerMockRecorder) CheckHealth(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckHealth", reflect.TypeOf((*MockDaemonServer)(nil).CheckHealth), arg0, arg1)
}
// DeleteTask mocks base method.
func (m *MockDaemonServer) DeleteTask(arg0 context.Context, arg1 *dfdaemon.DeleteTaskRequest) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockDaemonServerMockRecorder) DeleteTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockDaemonServer)(nil).DeleteTask), arg0, arg1)
}
// Download mocks base method.
func (m *MockDaemonServer) Download(arg0 *dfdaemon.DownRequest, arg1 dfdaemon.Daemon_DownloadServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Download", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Download indicates an expected call of Download.
func (mr *MockDaemonServerMockRecorder) Download(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Download", reflect.TypeOf((*MockDaemonServer)(nil).Download), arg0, arg1)
}
// ExportTask mocks base method.
func (m *MockDaemonServer) ExportTask(arg0 context.Context, arg1 *dfdaemon.ExportTaskRequest) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExportTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ExportTask indicates an expected call of ExportTask.
func (mr *MockDaemonServerMockRecorder) ExportTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTask", reflect.TypeOf((*MockDaemonServer)(nil).ExportTask), arg0, arg1)
}
// GetPieceTasks mocks base method.
func (m *MockDaemonServer) GetPieceTasks(arg0 context.Context, arg1 *base.PieceTaskRequest) (*base.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPieceTasks", arg0, arg1)
ret0, _ := ret[0].(*base.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPieceTasks indicates an expected call of GetPieceTasks.
func (mr *MockDaemonServerMockRecorder) GetPieceTasks(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceTasks", reflect.TypeOf((*MockDaemonServer)(nil).GetPieceTasks), arg0, arg1)
}
// ImportTask mocks base method.
func (m *MockDaemonServer) ImportTask(arg0 context.Context, arg1 *dfdaemon.ImportTaskRequest) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ImportTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ImportTask indicates an expected call of ImportTask.
func (mr *MockDaemonServerMockRecorder) ImportTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTask", reflect.TypeOf((*MockDaemonServer)(nil).ImportTask), arg0, arg1)
}
// StatTask mocks base method.
func (m *MockDaemonServer) StatTask(arg0 context.Context, arg1 *dfdaemon.StatTaskRequest) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StatTask indicates an expected call of StatTask.
func (mr *MockDaemonServerMockRecorder) StatTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockDaemonServer)(nil).StatTask), arg0, arg1)
}
// SyncPieceTasks mocks base method.
func (m *MockDaemonServer) SyncPieceTasks(arg0 dfdaemon.Daemon_SyncPieceTasksServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncPieceTasks", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SyncPieceTasks indicates an expected call of SyncPieceTasks.
func (mr *MockDaemonServerMockRecorder) SyncPieceTasks(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncPieceTasks", reflect.TypeOf((*MockDaemonServer)(nil).SyncPieceTasks), arg0)
}
// MockDaemon_DownloadServer is a mock of Daemon_DownloadServer interface.
type MockDaemon_DownloadServer struct {
ctrl *gomock.Controller
recorder *MockDaemon_DownloadServerMockRecorder
}
// MockDaemon_DownloadServerMockRecorder is the mock recorder for MockDaemon_DownloadServer.
type MockDaemon_DownloadServerMockRecorder struct {
mock *MockDaemon_DownloadServer
}
// NewMockDaemon_DownloadServer creates a new mock instance.
func NewMockDaemon_DownloadServer(ctrl *gomock.Controller) *MockDaemon_DownloadServer {
mock := &MockDaemon_DownloadServer{ctrl: ctrl}
mock.recorder = &MockDaemon_DownloadServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemon_DownloadServer) EXPECT() *MockDaemon_DownloadServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockDaemon_DownloadServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockDaemon_DownloadServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).Context))
}
// RecvMsg mocks base method.
func (m_2 *MockDaemon_DownloadServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDaemon_DownloadServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockDaemon_DownloadServer) Send(arg0 *dfdaemon.DownResult) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockDaemon_DownloadServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).Send), arg0)
}
// SendHeader mocks base method.
func (m *MockDaemon_DownloadServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockDaemon_DownloadServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockDaemon_DownloadServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockDaemon_DownloadServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockDaemon_DownloadServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockDaemon_DownloadServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockDaemon_DownloadServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockDaemon_DownloadServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockDaemon_DownloadServer)(nil).SetTrailer), arg0)
}
// MockDaemon_SyncPieceTasksServer is a mock of Daemon_SyncPieceTasksServer interface.
type MockDaemon_SyncPieceTasksServer struct {
ctrl *gomock.Controller
recorder *MockDaemon_SyncPieceTasksServerMockRecorder
}
// MockDaemon_SyncPieceTasksServerMockRecorder is the mock recorder for MockDaemon_SyncPieceTasksServer.
type MockDaemon_SyncPieceTasksServerMockRecorder struct {
mock *MockDaemon_SyncPieceTasksServer
}
// NewMockDaemon_SyncPieceTasksServer creates a new mock instance.
func NewMockDaemon_SyncPieceTasksServer(ctrl *gomock.Controller) *MockDaemon_SyncPieceTasksServer {
mock := &MockDaemon_SyncPieceTasksServer{ctrl: ctrl}
mock.recorder = &MockDaemon_SyncPieceTasksServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDaemon_SyncPieceTasksServer) EXPECT() *MockDaemon_SyncPieceTasksServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).Context))
}
// Recv mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) Recv() (*base.PieceTaskRequest, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*base.PieceTaskRequest)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockDaemon_SyncPieceTasksServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) Send(arg0 *base.PiecePacket) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).Send), arg0)
}
// SendHeader mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockDaemon_SyncPieceTasksServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockDaemon_SyncPieceTasksServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockDaemon_SyncPieceTasksServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockDaemon_SyncPieceTasksServer)(nil).SetTrailer), arg0)
}

20
pkg/rpc/dfdaemon/server/mocks/server_mock.go
View File

@ -8,8 +8,8 @@ import (
context "context"
reflect "reflect"
base "d7y.io/dragonfly/v2/pkg/rpc/base"
dfdaemon "d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
v1 "d7y.io/api/pkg/apis/common/v1"
v10 "d7y.io/api/pkg/apis/dfdaemon/v1"
gomock "github.com/golang/mock/gomock"
)
@ -51,7 +51,7 @@ func (mr *MockDaemonServerMockRecorder) CheckHealth(arg0 interface{}) *gomock.Ca
}
// DeleteTask mocks base method.
func (m *MockDaemonServer) DeleteTask(arg0 context.Context, arg1 *dfdaemon.DeleteTaskRequest) error {
func (m *MockDaemonServer) DeleteTask(arg0 context.Context, arg1 *v10.DeleteTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteTask", arg0, arg1)
ret0, _ := ret[0].(error)
@ -65,7 +65,7 @@ func (mr *MockDaemonServerMockRecorder) DeleteTask(arg0, arg1 interface{}) *gomo
}
// Download mocks base method.
func (m *MockDaemonServer) Download(arg0 context.Context, arg1 *dfdaemon.DownRequest, arg2 chan<- *dfdaemon.DownResult) error {
func (m *MockDaemonServer) Download(arg0 context.Context, arg1 *v10.DownRequest, arg2 chan<- *v10.DownResult) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Download", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
@ -79,7 +79,7 @@ func (mr *MockDaemonServerMockRecorder) Download(arg0, arg1, arg2 interface{}) *
}
// ExportTask mocks base method.
func (m *MockDaemonServer) ExportTask(arg0 context.Context, arg1 *dfdaemon.ExportTaskRequest) error {
func (m *MockDaemonServer) ExportTask(arg0 context.Context, arg1 *v10.ExportTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExportTask", arg0, arg1)
ret0, _ := ret[0].(error)
@ -93,10 +93,10 @@ func (mr *MockDaemonServerMockRecorder) ExportTask(arg0, arg1 interface{}) *gomo
}
// GetPieceTasks mocks base method.
func (m *MockDaemonServer) GetPieceTasks(arg0 context.Context, arg1 *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (m *MockDaemonServer) GetPieceTasks(arg0 context.Context, arg1 *v1.PieceTaskRequest) (*v1.PiecePacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPieceTasks", arg0, arg1)
ret0, _ := ret[0].(*base.PiecePacket)
ret0, _ := ret[0].(*v1.PiecePacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -108,7 +108,7 @@ func (mr *MockDaemonServerMockRecorder) GetPieceTasks(arg0, arg1 interface{}) *g
}
// ImportTask mocks base method.
func (m *MockDaemonServer) ImportTask(arg0 context.Context, arg1 *dfdaemon.ImportTaskRequest) error {
func (m *MockDaemonServer) ImportTask(arg0 context.Context, arg1 *v10.ImportTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ImportTask", arg0, arg1)
ret0, _ := ret[0].(error)
@ -122,7 +122,7 @@ func (mr *MockDaemonServerMockRecorder) ImportTask(arg0, arg1 interface{}) *gomo
}
// StatTask mocks base method.
func (m *MockDaemonServer) StatTask(arg0 context.Context, arg1 *dfdaemon.StatTaskRequest) error {
func (m *MockDaemonServer) StatTask(arg0 context.Context, arg1 *v10.StatTaskRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
ret0, _ := ret[0].(error)
@ -136,7 +136,7 @@ func (mr *MockDaemonServerMockRecorder) StatTask(arg0, arg1 interface{}) *gomock
}
// SyncPieceTasks mocks base method.
func (m *MockDaemonServer) SyncPieceTasks(arg0 dfdaemon.Daemon_SyncPieceTasksServer) error {
func (m *MockDaemonServer) SyncPieceTasks(arg0 v10.Daemon_SyncPieceTasksServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SyncPieceTasks", arg0)
ret0, _ := ret[0].(error)

45
pkg/rpc/dfdaemon/server/server.go
View File

@ -26,46 +26,47 @@ import (
"google.golang.org/grpc/peer"
"google.golang.org/protobuf/types/known/emptypb"
commonv1 "d7y.io/api/pkg/apis/common/v1"
dfdaemonv1 "d7y.io/api/pkg/apis/dfdaemon/v1"
"d7y.io/dragonfly/v2/internal/dferrors"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/dfdaemon"
"d7y.io/dragonfly/v2/pkg/safe"
)
// DaemonServer refer to dfdaemon.DaemonServer
// DaemonServer refer to dfdaemonv1.DaemonServer
type DaemonServer interface {
// Download triggers client to download file
Download(context.Context, *dfdaemon.DownRequest, chan<- *dfdaemon.DownResult) error
Download(context.Context, *dfdaemonv1.DownRequest, chan<- *dfdaemonv1.DownResult) error
// GetPieceTasks get piece tasks from other peers
GetPieceTasks(context.Context, *base.PieceTaskRequest) (*base.PiecePacket, error)
GetPieceTasks(context.Context, *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error)
// SyncPieceTasks sync piece tasks info with other peers
SyncPieceTasks(dfdaemon.Daemon_SyncPieceTasksServer) error
SyncPieceTasks(dfdaemonv1.Daemon_SyncPieceTasksServer) error
// CheckHealth check daemon health
CheckHealth(context.Context) error
// Check if the given task exists in P2P cache system
StatTask(context.Context, *dfdaemon.StatTaskRequest) error
StatTask(context.Context, *dfdaemonv1.StatTaskRequest) error
// Import the given file into P2P cache system
ImportTask(context.Context, *dfdaemon.ImportTaskRequest) error
ImportTask(context.Context, *dfdaemonv1.ImportTaskRequest) error
// Export or download file from P2P cache system
ExportTask(context.Context, *dfdaemon.ExportTaskRequest) error
ExportTask(context.Context, *dfdaemonv1.ExportTaskRequest) error
// Delete file from P2P cache system
DeleteTask(context.Context, *dfdaemon.DeleteTaskRequest) error
DeleteTask(context.Context, *dfdaemonv1.DeleteTaskRequest) error
}
type proxy struct {
server DaemonServer
dfdaemon.UnimplementedDaemonServer
dfdaemonv1.UnimplementedDaemonServer
}
func New(daemonServer DaemonServer, opts ...grpc.ServerOption) *grpc.Server {
grpcServer := grpc.NewServer(append(rpc.DefaultServerOptions(), opts...)...)
dfdaemon.RegisterDaemonServer(grpcServer, &proxy{server: daemonServer})
dfdaemonv1.RegisterDaemonServer(grpcServer, &proxy{server: daemonServer})
return grpcServer
}
func (p *proxy) Download(req *dfdaemon.DownRequest, stream dfdaemon.Daemon_DownloadServer) (err error) {
func (p *proxy) Download(req *dfdaemonv1.DownRequest, stream dfdaemonv1.Daemon_DownloadServer) (err error) {
ctx, cancel := context.WithCancel(stream.Context())
defer cancel()
@ -76,7 +77,7 @@ func (p *proxy) Download(req *dfdaemon.DownRequest, stream dfdaemon.Daemon_Downl
logger.Infof("trigger download for url: %s, from: %s, uuid: %s", req.Url, peerAddr, req.Uuid)
errChan := make(chan error, 10)
drc := make(chan *dfdaemon.DownResult, 4)
drc := make(chan *dfdaemonv1.DownResult, 4)
once := new(sync.Once)
closeDrc := func() {
@ -97,11 +98,11 @@ func (p *proxy) Download(req *dfdaemon.DownRequest, stream dfdaemon.Daemon_Downl
return
}
func (p *proxy) GetPieceTasks(ctx context.Context, ptr *base.PieceTaskRequest) (*base.PiecePacket, error) {
func (p *proxy) GetPieceTasks(ctx context.Context, ptr *commonv1.PieceTaskRequest) (*commonv1.PiecePacket, error) {
return p.server.GetPieceTasks(ctx, ptr)
}
func (p *proxy) SyncPieceTasks(sync dfdaemon.Daemon_SyncPieceTasksServer) error {
func (p *proxy) SyncPieceTasks(sync dfdaemonv1.Daemon_SyncPieceTasksServer) error {
return p.server.SyncPieceTasks(sync)
}
@ -109,23 +110,23 @@ func (p *proxy) CheckHealth(ctx context.Context, req *emptypb.Empty) (*emptypb.E
return new(emptypb.Empty), p.server.CheckHealth(ctx)
}
func (p *proxy) StatTask(ctx context.Context, req *dfdaemon.StatTaskRequest) (*emptypb.Empty, error) {
func (p *proxy) StatTask(ctx context.Context, req *dfdaemonv1.StatTaskRequest) (*emptypb.Empty, error) {
return new(emptypb.Empty), p.server.StatTask(ctx, req)
}
func (p *proxy) ImportTask(ctx context.Context, req *dfdaemon.ImportTaskRequest) (*emptypb.Empty, error) {
func (p *proxy) ImportTask(ctx context.Context, req *dfdaemonv1.ImportTaskRequest) (*emptypb.Empty, error) {
return new(emptypb.Empty), p.server.ImportTask(ctx, req)
}
func (p *proxy) ExportTask(ctx context.Context, req *dfdaemon.ExportTaskRequest) (*emptypb.Empty, error) {
func (p *proxy) ExportTask(ctx context.Context, req *dfdaemonv1.ExportTaskRequest) (*emptypb.Empty, error) {
return new(emptypb.Empty), p.server.ExportTask(ctx, req)
}
func (p *proxy) DeleteTask(ctx context.Context, req *dfdaemon.DeleteTaskRequest) (*emptypb.Empty, error) {
func (p *proxy) DeleteTask(ctx context.Context, req *dfdaemonv1.DeleteTaskRequest) (*emptypb.Empty, error) {
return new(emptypb.Empty), p.server.DeleteTask(ctx, req)
}
func send(drc chan *dfdaemon.DownResult, closeDrc func(), stream dfdaemon.Daemon_DownloadServer, errChan chan error) {
func send(drc chan *dfdaemonv1.DownResult, closeDrc func(), stream dfdaemonv1.Daemon_DownloadServer, errChan chan error) {
err := safe.Call(func() {
defer closeDrc()
@ -148,7 +149,7 @@ func send(drc chan *dfdaemon.DownResult, closeDrc func(), stream dfdaemon.Daemon
}
}
func call(ctx context.Context, drc chan *dfdaemon.DownResult, p *proxy, req *dfdaemon.DownRequest, errChan chan error) {
func call(ctx context.Context, drc chan *dfdaemonv1.DownResult, p *proxy, req *dfdaemonv1.DownRequest, errChan chan error) {
err := safe.Call(func() {
if err := p.server.Download(ctx, req, drc); err != nil {
errChan <- err

178
pkg/rpc/errordetails/error_details.pb.go
View File

@ -1,178 +0,0 @@
//
// Copyright 2022 The Dragonfly Authors
//
// Licensed 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.28.0
// protoc v3.19.4
// source: pkg/rpc/errordetails/error_details.proto
package errordetails
import (
base "d7y.io/dragonfly/v2/pkg/rpc/base"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type SourceError struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Temporary bool `protobuf:"varint,1,opt,name=temporary,proto3" json:"temporary,omitempty"`
// source response metadata, eg: HTTP Status Code, HTTP Status, HTTP Header
Metadata *base.ExtendAttribute `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *SourceError) Reset() {
*x = SourceError{}
if protoimpl.UnsafeEnabled {
mi := &file_pkg_rpc_errordetails_error_details_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SourceError) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SourceError) ProtoMessage() {}
func (x *SourceError) ProtoReflect() protoreflect.Message {
mi := &file_pkg_rpc_errordetails_error_details_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SourceError.ProtoReflect.Descriptor instead.
func (*SourceError) Descriptor() ([]byte, []int) {
return file_pkg_rpc_errordetails_error_details_proto_rawDescGZIP(), []int{0}
}
func (x *SourceError) GetTemporary() bool {
if x != nil {
return x.Temporary
}
return false
}
func (x *SourceError) GetMetadata() *base.ExtendAttribute {
if x != nil {
return x.Metadata
}
return nil
}
var File_pkg_rpc_errordetails_error_details_proto protoreflect.FileDescriptor
var file_pkg_rpc_errordetails_error_details_proto_rawDesc = []byte{
0x0a, 0x28, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x64,
0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x64, 0x65, 0x74,
0x61, 0x69, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x65, 0x72, 0x72, 0x6f,
0x72, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x17, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70,
0x63, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x22, 0x5e, 0x0a, 0x0b, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72,
0x12, 0x1c, 0x0a, 0x09, 0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x08, 0x52, 0x09, 0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x12, 0x31,
0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x15, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x41, 0x74,
0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x42, 0x2a, 0x5a, 0x28, 0x64, 0x37, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x64, 0x72, 0x61, 0x67,
0x6f, 0x6e, 0x66, 0x6c, 0x79, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63,
0x2f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x62, 0x06, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_pkg_rpc_errordetails_error_details_proto_rawDescOnce sync.Once
file_pkg_rpc_errordetails_error_details_proto_rawDescData = file_pkg_rpc_errordetails_error_details_proto_rawDesc
)
func file_pkg_rpc_errordetails_error_details_proto_rawDescGZIP() []byte {
file_pkg_rpc_errordetails_error_details_proto_rawDescOnce.Do(func() {
file_pkg_rpc_errordetails_error_details_proto_rawDescData = protoimpl.X.CompressGZIP(file_pkg_rpc_errordetails_error_details_proto_rawDescData)
})
return file_pkg_rpc_errordetails_error_details_proto_rawDescData
}
var file_pkg_rpc_errordetails_error_details_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_pkg_rpc_errordetails_error_details_proto_goTypes = []interface{}{
(*SourceError)(nil), // 0: errordetails.SourceError
(*base.ExtendAttribute)(nil), // 1: base.ExtendAttribute
}
var file_pkg_rpc_errordetails_error_details_proto_depIdxs = []int32{
1, // 0: errordetails.SourceError.metadata:type_name -> base.ExtendAttribute
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_pkg_rpc_errordetails_error_details_proto_init() }
func file_pkg_rpc_errordetails_error_details_proto_init() {
if File_pkg_rpc_errordetails_error_details_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_pkg_rpc_errordetails_error_details_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SourceError); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_pkg_rpc_errordetails_error_details_proto_rawDesc,
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_pkg_rpc_errordetails_error_details_proto_goTypes,
DependencyIndexes: file_pkg_rpc_errordetails_error_details_proto_depIdxs,
MessageInfos: file_pkg_rpc_errordetails_error_details_proto_msgTypes,
}.Build()
File_pkg_rpc_errordetails_error_details_proto = out.File
file_pkg_rpc_errordetails_error_details_proto_rawDesc = nil
file_pkg_rpc_errordetails_error_details_proto_goTypes = nil
file_pkg_rpc_errordetails_error_details_proto_depIdxs = nil
}

111
pkg/rpc/errordetails/error_details.pb.validate.go
View File

@ -1,111 +0,0 @@
// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: pkg/rpc/errordetails/error_details.proto
package errordetails
import (
"bytes"
"errors"
"fmt"
"net"
"net/mail"
"net/url"
"regexp"
"strings"
"time"
"unicode/utf8"
"google.golang.org/protobuf/types/known/anypb"
)
// ensure the imports are used
var (
_ = bytes.MinRead
_ = errors.New("")
_ = fmt.Print
_ = utf8.UTFMax
_ = (*regexp.Regexp)(nil)
_ = (*strings.Reader)(nil)
_ = net.IPv4len
_ = time.Duration(0)
_ = (*url.URL)(nil)
_ = (*mail.Address)(nil)
_ = anypb.Any{}
)
// Validate checks the field values on SourceError with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *SourceError) Validate() error {
if m == nil {
return nil
}
// no validation rules for Temporary
if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok {
if err := v.Validate(); err != nil {
return SourceErrorValidationError{
field: "Metadata",
reason: "embedded message failed validation",
cause: err,
}
}
}
return nil
}
// SourceErrorValidationError is the validation error returned by
// SourceError.Validate if the designated constraints aren't met.
type SourceErrorValidationError struct {
field string
reason string
cause error
key bool
}
// Field function returns field value.
func (e SourceErrorValidationError) Field() string { return e.field }
// Reason function returns reason value.
func (e SourceErrorValidationError) Reason() string { return e.reason }
// Cause function returns cause value.
func (e SourceErrorValidationError) Cause() error { return e.cause }
// Key function returns key value.
func (e SourceErrorValidationError) Key() bool { return e.key }
// ErrorName returns error name.
func (e SourceErrorValidationError) ErrorName() string { return "SourceErrorValidationError" }
// Error satisfies the builtin error interface
func (e SourceErrorValidationError) Error() string {
cause := ""
if e.cause != nil {
cause = fmt.Sprintf(" | caused by: %v", e.cause)
}
key := ""
if e.key {
key = "key for "
}
return fmt.Sprintf(
"invalid %sSourceError.%s: %s%s",
key,
e.field,
e.reason,
cause)
}
var _ error = SourceErrorValidationError{}
var _ interface {
Field() string
Reason() string
Key() bool
Cause() error
ErrorName() string
} = SourceErrorValidationError{}

30
pkg/rpc/errordetails/error_details.proto
View File

@ -1,30 +0,0 @@
/*
* Copyright 2022 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package errordetails;
import "pkg/rpc/base/base.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/errordetails";
message SourceError {
bool temporary = 1;
// source response metadata, eg: HTTP Status Code, HTTP Status, HTTP Header
base.ExtendAttribute metadata = 2;
}

37
pkg/rpc/manager/client/client.go
View File

@ -32,10 +32,11 @@ import (
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/status"
managerv1 "d7y.io/api/pkg/apis/manager/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/reachable"
"d7y.io/dragonfly/v2/pkg/rpc/manager"
)
const (
@ -49,25 +50,25 @@ const (
// Client is the interface for grpc client.
type Client interface {
// Update Seed peer configuration.
UpdateSeedPeer(*manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error)
UpdateSeedPeer(*managerv1.UpdateSeedPeerRequest) (*managerv1.SeedPeer, error)
// Get Scheduler and Scheduler cluster configuration.
GetScheduler(*manager.GetSchedulerRequest) (*manager.Scheduler, error)
GetScheduler(*managerv1.GetSchedulerRequest) (*managerv1.Scheduler, error)
// Update scheduler configuration.
UpdateScheduler(*manager.UpdateSchedulerRequest) (*manager.Scheduler, error)
UpdateScheduler(*managerv1.UpdateSchedulerRequest) (*managerv1.Scheduler, error)
// List acitve schedulers configuration.
ListSchedulers(*manager.ListSchedulersRequest) (*manager.ListSchedulersResponse, error)
ListSchedulers(*managerv1.ListSchedulersRequest) (*managerv1.ListSchedulersResponse, error)
// Get object storage configuration.
GetObjectStorage(*manager.GetObjectStorageRequest) (*manager.ObjectStorage, error)
GetObjectStorage(*managerv1.GetObjectStorageRequest) (*managerv1.ObjectStorage, error)
// List buckets configuration.
ListBuckets(*manager.ListBucketsRequest) (*manager.ListBucketsResponse, error)
ListBuckets(*managerv1.ListBucketsRequest) (*managerv1.ListBucketsResponse, error)
// KeepAlive with manager.
KeepAlive(time.Duration, *manager.KeepAliveRequest)
KeepAlive(time.Duration, *managerv1.KeepAliveRequest)
// Close client connect.
Close() error
@ -75,7 +76,7 @@ type Client interface {
// client provides manager grpc function.
type client struct {
manager.ManagerClient
managerv1.ManagerClient
conn *grpc.ClientConn
}
@ -103,7 +104,7 @@ func New(target string) (Client, error) {
}
return &client{
ManagerClient: manager.NewManagerClient(conn),
ManagerClient: managerv1.NewManagerClient(conn),
conn: conn,
}, nil
}
@ -123,7 +124,7 @@ func NewWithAddrs(netAddrs []dfnet.NetAddr) (Client, error) {
}
// Update SeedPeer configuration.
func (c *client) UpdateSeedPeer(req *manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error) {
func (c *client) UpdateSeedPeer(req *managerv1.UpdateSeedPeerRequest) (*managerv1.SeedPeer, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -131,7 +132,7 @@ func (c *client) UpdateSeedPeer(req *manager.UpdateSeedPeerRequest) (*manager.Se
}
// Get Scheduler and Scheduler cluster configuration.
func (c *client) GetScheduler(req *manager.GetSchedulerRequest) (*manager.Scheduler, error) {
func (c *client) GetScheduler(req *managerv1.GetSchedulerRequest) (*managerv1.Scheduler, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -139,7 +140,7 @@ func (c *client) GetScheduler(req *manager.GetSchedulerRequest) (*manager.Schedu
}
// Update scheduler configuration.
func (c *client) UpdateScheduler(req *manager.UpdateSchedulerRequest) (*manager.Scheduler, error) {
func (c *client) UpdateScheduler(req *managerv1.UpdateSchedulerRequest) (*managerv1.Scheduler, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -147,7 +148,7 @@ func (c *client) UpdateScheduler(req *manager.UpdateSchedulerRequest) (*manager.
}
// List acitve schedulers configuration.
func (c *client) ListSchedulers(req *manager.ListSchedulersRequest) (*manager.ListSchedulersResponse, error) {
func (c *client) ListSchedulers(req *managerv1.ListSchedulersRequest) (*managerv1.ListSchedulersResponse, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -155,7 +156,7 @@ func (c *client) ListSchedulers(req *manager.ListSchedulersRequest) (*manager.Li
}
// Get object storage configuration.
func (c *client) GetObjectStorage(req *manager.GetObjectStorageRequest) (*manager.ObjectStorage, error) {
func (c *client) GetObjectStorage(req *managerv1.GetObjectStorageRequest) (*managerv1.ObjectStorage, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -163,7 +164,7 @@ func (c *client) GetObjectStorage(req *manager.GetObjectStorageRequest) (*manage
}
// List buckets configuration.
func (c *client) ListBuckets(req *manager.ListBucketsRequest) (*manager.ListBucketsResponse, error) {
func (c *client) ListBuckets(req *managerv1.ListBucketsRequest) (*managerv1.ListBucketsResponse, error) {
ctx, cancel := context.WithTimeout(context.Background(), contextTimeout)
defer cancel()
@ -171,7 +172,7 @@ func (c *client) ListBuckets(req *manager.ListBucketsRequest) (*manager.ListBuck
}
// List acitve schedulers configuration.
func (c *client) KeepAlive(interval time.Duration, keepalive *manager.KeepAliveRequest) {
func (c *client) KeepAlive(interval time.Duration, keepalive *managerv1.KeepAliveRequest) {
retry:
ctx, cancel := context.WithCancel(context.Background())
stream, err := c.ManagerClient.KeepAlive(ctx)
@ -191,7 +192,7 @@ retry:
for {
select {
case <-tick.C:
if err := stream.Send(&manager.KeepAliveRequest{
if err := stream.Send(&managerv1.KeepAliveRequest{
SourceType: keepalive.SourceType,
HostName: keepalive.HostName,
Ip: keepalive.Ip,

28
pkg/rpc/manager/client/mocks/client_mock.go
View File

@ -8,7 +8,7 @@ import (
reflect "reflect"
time "time"
manager "d7y.io/dragonfly/v2/pkg/rpc/manager"
v1 "d7y.io/api/pkg/apis/manager/v1"
gomock "github.com/golang/mock/gomock"
)
@ -50,10 +50,10 @@ func (mr *MockClientMockRecorder) Close() *gomock.Call {
}
// GetObjectStorage mocks base method.
func (m *MockClient) GetObjectStorage(arg0 *manager.GetObjectStorageRequest) (*manager.ObjectStorage, error) {
func (m *MockClient) GetObjectStorage(arg0 *v1.GetObjectStorageRequest) (*v1.ObjectStorage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetObjectStorage", arg0)
ret0, _ := ret[0].(*manager.ObjectStorage)
ret0, _ := ret[0].(*v1.ObjectStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -65,10 +65,10 @@ func (mr *MockClientMockRecorder) GetObjectStorage(arg0 interface{}) *gomock.Cal
}
// GetScheduler mocks base method.
func (m *MockClient) GetScheduler(arg0 *manager.GetSchedulerRequest) (*manager.Scheduler, error) {
func (m *MockClient) GetScheduler(arg0 *v1.GetSchedulerRequest) (*v1.Scheduler, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetScheduler", arg0)
ret0, _ := ret[0].(*manager.Scheduler)
ret0, _ := ret[0].(*v1.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -80,7 +80,7 @@ func (mr *MockClientMockRecorder) GetScheduler(arg0 interface{}) *gomock.Call {
}
// KeepAlive mocks base method.
func (m *MockClient) KeepAlive(arg0 time.Duration, arg1 *manager.KeepAliveRequest) {
func (m *MockClient) KeepAlive(arg0 time.Duration, arg1 *v1.KeepAliveRequest) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "KeepAlive", arg0, arg1)
}
@ -92,10 +92,10 @@ func (mr *MockClientMockRecorder) KeepAlive(arg0, arg1 interface{}) *gomock.Call
}
// ListBuckets mocks base method.
func (m *MockClient) ListBuckets(arg0 *manager.ListBucketsRequest) (*manager.ListBucketsResponse, error) {
func (m *MockClient) ListBuckets(arg0 *v1.ListBucketsRequest) (*v1.ListBucketsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListBuckets", arg0)
ret0, _ := ret[0].(*manager.ListBucketsResponse)
ret0, _ := ret[0].(*v1.ListBucketsResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -107,10 +107,10 @@ func (mr *MockClientMockRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
}
// ListSchedulers mocks base method.
func (m *MockClient) ListSchedulers(arg0 *manager.ListSchedulersRequest) (*manager.ListSchedulersResponse, error) {
func (m *MockClient) ListSchedulers(arg0 *v1.ListSchedulersRequest) (*v1.ListSchedulersResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListSchedulers", arg0)
ret0, _ := ret[0].(*manager.ListSchedulersResponse)
ret0, _ := ret[0].(*v1.ListSchedulersResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -122,10 +122,10 @@ func (mr *MockClientMockRecorder) ListSchedulers(arg0 interface{}) *gomock.Call
}
// UpdateScheduler mocks base method.
func (m *MockClient) UpdateScheduler(arg0 *manager.UpdateSchedulerRequest) (*manager.Scheduler, error) {
func (m *MockClient) UpdateScheduler(arg0 *v1.UpdateSchedulerRequest) (*v1.Scheduler, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateScheduler", arg0)
ret0, _ := ret[0].(*manager.Scheduler)
ret0, _ := ret[0].(*v1.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -137,10 +137,10 @@ func (mr *MockClientMockRecorder) UpdateScheduler(arg0 interface{}) *gomock.Call
}
// UpdateSeedPeer mocks base method.
func (m *MockClient) UpdateSeedPeer(arg0 *manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error) {
func (m *MockClient) UpdateSeedPeer(arg0 *v1.UpdateSeedPeerRequest) (*v1.SeedPeer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateSeedPeer", arg0)
ret0, _ := ret[0].(*manager.SeedPeer)
ret0, _ := ret[0].(*v1.SeedPeer)
ret1, _ := ret[1].(error)
return ret0, ret1
}

2639
pkg/rpc/manager/manager.pb.go
View File

File diff suppressed because it is too large Load Diff

1990
pkg/rpc/manager/manager.pb.validate.go
View File

File diff suppressed because it is too large Load Diff

321
pkg/rpc/manager/manager.proto
View File

@ -1,321 +0,0 @@
/*
* Copyright 2020 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package manager;
import "google/protobuf/empty.proto";
import "validate/validate.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/manager";
// Request source type.
enum SourceType {
// Scheduler service.
SCHEDULER_SOURCE = 0;
// Peer service.
PEER_SOURCE = 1;
// SeedPeer service.
SEED_PEER_SOURCE = 2;
}
// SecurityGroup represents security group of cluster.
message SecurityGroup {
// Group id.
uint64 id = 1;
// Group name.
string name = 2;
// Group biography.
string bio = 3;
// Group domain.
string domain = 4;
// Group proxy domain.
string proxy_domain = 5;
}
// SeedPeerCluster represents cluster of seed peer.
message SeedPeerCluster {
// Cluster id.
uint64 id = 1;
// Cluster name.
string name = 2;
// Cluster biography.
string bio = 3;
// Cluster configuration.
bytes config = 4;
// Cluster scopes.
bytes scopes = 5;
// Security group to which the seed peer cluster belongs.
SecurityGroup security_group = 6;
}
// SeedPeer represents seed peer for network.
message SeedPeer {
// Seed peer id.
uint64 id = 1;
// Seed peer hostname.
string host_name = 2;
// Seed peer type.
string type = 3;
// Seed peer idc.
string idc = 5;
// Seed peer network topology.
string net_topology = 6;
// Seed peer location.
string location = 7;
// Seed peer ip.
string ip = 8;
// Seed peer grpc port.
int32 port = 9;
// Seed peer download port.
int32 download_port = 10;
// Seed peer state.
string state = 11;
// ID of the cluster to which the seed peer belongs.
uint64 seed_peer_cluster_id = 12;
// Cluster to which the seed peer belongs.
SeedPeerCluster seed_peer_cluster = 13;
// Schedulers included in seed peer.
repeated Scheduler schedulers = 14;
// Seed peer object storage port.
int32 object_storage_port = 15;
}
// GetSeedPeerRequest represents request of GetSeedPeer.
message GetSeedPeerRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Seed peer hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// ID of the cluster to which the seed peer belongs.
uint64 seed_peer_cluster_id = 3 [(validate.rules).uint64 = {gte: 1}];
// Seed peer ip.
string ip = 4 [(validate.rules).string = {ip: true, ignore_empty: true}];
}
// UpdateSeedPeerRequest represents request of UpdateSeedPeer.
message UpdateSeedPeerRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Seed peer hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// Seed peer type.
string type = 3 [(validate.rules).string = {in: ["super", "strong", "weak"]}];
// Seed peer idc.
string idc = 5 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Seed peer network topology.
string net_topology = 6 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Seed peer location.
string location = 7 [(validate.rules).string = {max_len: 1024, ignore_empty: true}];
// Seed peer ip.
string ip = 8 [(validate.rules).string = {ip: true}];
// Seed peer port.
int32 port = 9 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// Seed peer download port.
int32 download_port = 10 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// ID of the cluster to which the seed peer belongs.
uint64 seed_peer_cluster_id = 11 [(validate.rules).uint64 = {gte: 1}];
// Seed peer object storage port.
int32 object_storage_port = 12 [(validate.rules).int32 = {gte: 1024, lt: 65535, ignore_empty: true}];
}
// SeedPeerCluster represents cluster of scheduler.
message SchedulerCluster {
// Cluster id.
uint64 id = 1;
// Cluster name.
string name = 2;
// Cluster biography.
string bio = 3;
// Cluster config.
bytes config = 4;
// Cluster client config.
bytes client_config = 5;
// Cluster scopes.
bytes scopes = 6;
// Security group to which the scheduler cluster belongs.
SecurityGroup security_group = 7;
}
// SeedPeerCluster represents scheduler for network.
message Scheduler {
// Scheduler id.
uint64 id = 1;
// Scheduler hostname.
string host_name = 2;
// Deprecated: Do not use.
string vips = 3;
// Scheduler idc.
string idc = 4;
// Scheduler location.
string location = 5;
// Deprecated: Use net_topology instead.
bytes net_config = 6;
// Scheduler ip.
string ip = 7;
// Scheduler grpc port.
int32 port = 8;
// Scheduler state.
string state = 9;
// ID of the cluster to which the scheduler belongs.
uint64 scheduler_cluster_id = 10;
// Cluster to which the scheduler belongs.
SchedulerCluster scheduler_cluster = 11;
// Seed peers to which the scheduler belongs.
repeated SeedPeer seed_peers = 13;
// Scheduler network topology.
string net_topology = 14;
}
// GetSchedulerRequest represents request of GetScheduler.
message GetSchedulerRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Scheduler hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// ID of the cluster to which the scheduler belongs.
uint64 scheduler_cluster_id = 3 [(validate.rules).uint64 = {gte: 1}];
// Scheduler ip.
string ip = 4 [(validate.rules).string = {ip: true, ignore_empty: true}];
}
// UpdateSchedulerRequest represents request of UpdateScheduler.
message UpdateSchedulerRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Scheduler hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// ID of the cluster to which the scheduler belongs.
uint64 scheduler_cluster_id = 3 [(validate.rules).uint64 = {gte: 1}];
// Deprecated: Do not use.
string vips = 4 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Scheduler idc.
string idc = 5 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Scheduler location.
string location = 6 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Deprecated: Use net_topology instead.
bytes net_config = 7 [(validate.rules).bytes = {min_len: 1, ignore_empty: true}];
// Scheduler ip.
string ip = 8 [(validate.rules).string = {ip: true}];
// Scheduler port.
int32 port = 9 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// Scheduler network topology.
string net_topology = 10 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
}
// ListSchedulersRequest represents request of ListSchedulers.
message ListSchedulersRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Source service hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// Source service ip.
string ip = 3 [(validate.rules).string.ip = true];
// Source service host information.
map<string, string> host_info = 5 [(validate.rules).map.ignore_empty = true];
}
// ListSchedulersResponse represents response of ListSchedulers.
message ListSchedulersResponse {
// Schedulers to which the source service belongs.
repeated Scheduler schedulers = 1;
}
// ObjectStorage represents config of object storage.
message ObjectStorage {
// Object storage name of type.
string name = 1 [(validate.rules).string = {min_len: 1, max_len: 1024}];
// Storage region.
string region = 2 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Datacenter endpoint.
string endpoint = 3 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Access key id.
string access_key = 4 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
// Access key secret.
string secret_key = 5 [(validate.rules).string = {min_len: 1, max_len: 1024, ignore_empty: true}];
}
// GetObjectStorageRequest represents request of GetObjectStorage.
message GetObjectStorageRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Source service hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// Source service ip.
string ip = 3 [(validate.rules).string.ip = true];
}
// Bucket represents config of bucket.
message Bucket {
// Bucket name.
string name = 1 [(validate.rules).string = {min_len: 1, max_len: 1024}];
}
// ListSchedulersRequest represents request of ListBuckets.
message ListBucketsRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Source service hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// Source service ip.
string ip = 3 [(validate.rules).string.ip = true];
}
// ListBucketsResponse represents response of ListBuckets.
message ListBucketsResponse {
// Bucket configs.
repeated Bucket buckets = 1;
}
// KeepAliveRequest represents request of KeepAlive.
message KeepAliveRequest {
// Request source type.
SourceType source_type = 1 [(validate.rules).enum.defined_only = true];
// Source service hostname.
string host_name = 2 [(validate.rules).string.hostname = true];
// ID of the cluster to which the source service belongs.
uint64 cluster_id = 3 [(validate.rules).uint64 = {gte: 1}];
// Source service ip.
string ip = 4 [(validate.rules).string = {ip: true, ignore_empty: true}];
}
// Manager RPC Service.
service Manager {
// Get SeedPeer and SeedPeer cluster configuration.
rpc GetSeedPeer(GetSeedPeerRequest) returns(SeedPeer);
// Update SeedPeer configuration.
rpc UpdateSeedPeer(UpdateSeedPeerRequest) returns(SeedPeer);
// Get Scheduler and Scheduler cluster configuration.
rpc GetScheduler(GetSchedulerRequest)returns(Scheduler);
// Update scheduler configuration.
rpc UpdateScheduler(UpdateSchedulerRequest) returns(Scheduler);
// List acitve schedulers configuration.
rpc ListSchedulers(ListSchedulersRequest)returns(ListSchedulersResponse);
// Get ObjectStorage configuration.
rpc GetObjectStorage(GetObjectStorageRequest) returns(ObjectStorage);
// List buckets configuration.
rpc ListBuckets(ListBucketsRequest)returns(ListBucketsResponse);
// KeepAlive with manager.
rpc KeepAlive(stream KeepAliveRequest)returns(google.protobuf.Empty);
}

612
pkg/rpc/manager/mocks/manager_mock.go
View File

@ -1,612 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: manager/manager.pb.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
manager "d7y.io/dragonfly/v2/pkg/rpc/manager"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
metadata "google.golang.org/grpc/metadata"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// MockManagerClient is a mock of ManagerClient interface.
type MockManagerClient struct {
ctrl *gomock.Controller
recorder *MockManagerClientMockRecorder
}
// MockManagerClientMockRecorder is the mock recorder for MockManagerClient.
type MockManagerClientMockRecorder struct {
mock *MockManagerClient
}
// NewMockManagerClient creates a new mock instance.
func NewMockManagerClient(ctrl *gomock.Controller) *MockManagerClient {
mock := &MockManagerClient{ctrl: ctrl}
mock.recorder = &MockManagerClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManagerClient) EXPECT() *MockManagerClientMockRecorder {
return m.recorder
}
// GetObjectStorage mocks base method.
func (m *MockManagerClient) GetObjectStorage(ctx context.Context, in *manager.GetObjectStorageRequest, opts ...grpc.CallOption) (*manager.ObjectStorage, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetObjectStorage", varargs...)
ret0, _ := ret[0].(*manager.ObjectStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetObjectStorage indicates an expected call of GetObjectStorage.
func (mr *MockManagerClientMockRecorder) GetObjectStorage(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectStorage", reflect.TypeOf((*MockManagerClient)(nil).GetObjectStorage), varargs...)
}
// GetScheduler mocks base method.
func (m *MockManagerClient) GetScheduler(ctx context.Context, in *manager.GetSchedulerRequest, opts ...grpc.CallOption) (*manager.Scheduler, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetScheduler", varargs...)
ret0, _ := ret[0].(*manager.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetScheduler indicates an expected call of GetScheduler.
func (mr *MockManagerClientMockRecorder) GetScheduler(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScheduler", reflect.TypeOf((*MockManagerClient)(nil).GetScheduler), varargs...)
}
// GetSeedPeer mocks base method.
func (m *MockManagerClient) GetSeedPeer(ctx context.Context, in *manager.GetSeedPeerRequest, opts ...grpc.CallOption) (*manager.SeedPeer, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetSeedPeer", varargs...)
ret0, _ := ret[0].(*manager.SeedPeer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSeedPeer indicates an expected call of GetSeedPeer.
func (mr *MockManagerClientMockRecorder) GetSeedPeer(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeer", reflect.TypeOf((*MockManagerClient)(nil).GetSeedPeer), varargs...)
}
// KeepAlive mocks base method.
func (m *MockManagerClient) KeepAlive(ctx context.Context, opts ...grpc.CallOption) (manager.Manager_KeepAliveClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "KeepAlive", varargs...)
ret0, _ := ret[0].(manager.Manager_KeepAliveClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// KeepAlive indicates an expected call of KeepAlive.
func (mr *MockManagerClientMockRecorder) KeepAlive(ctx interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeepAlive", reflect.TypeOf((*MockManagerClient)(nil).KeepAlive), varargs...)
}
// ListBuckets mocks base method.
func (m *MockManagerClient) ListBuckets(ctx context.Context, in *manager.ListBucketsRequest, opts ...grpc.CallOption) (*manager.ListBucketsResponse, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListBuckets", varargs...)
ret0, _ := ret[0].(*manager.ListBucketsResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBuckets indicates an expected call of ListBuckets.
func (mr *MockManagerClientMockRecorder) ListBuckets(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockManagerClient)(nil).ListBuckets), varargs...)
}
// ListSchedulers mocks base method.
func (m *MockManagerClient) ListSchedulers(ctx context.Context, in *manager.ListSchedulersRequest, opts ...grpc.CallOption) (*manager.ListSchedulersResponse, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListSchedulers", varargs...)
ret0, _ := ret[0].(*manager.ListSchedulersResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListSchedulers indicates an expected call of ListSchedulers.
func (mr *MockManagerClientMockRecorder) ListSchedulers(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSchedulers", reflect.TypeOf((*MockManagerClient)(nil).ListSchedulers), varargs...)
}
// UpdateScheduler mocks base method.
func (m *MockManagerClient) UpdateScheduler(ctx context.Context, in *manager.UpdateSchedulerRequest, opts ...grpc.CallOption) (*manager.Scheduler, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateScheduler", varargs...)
ret0, _ := ret[0].(*manager.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UpdateScheduler indicates an expected call of UpdateScheduler.
func (mr *MockManagerClientMockRecorder) UpdateScheduler(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScheduler", reflect.TypeOf((*MockManagerClient)(nil).UpdateScheduler), varargs...)
}
// UpdateSeedPeer mocks base method.
func (m *MockManagerClient) UpdateSeedPeer(ctx context.Context, in *manager.UpdateSeedPeerRequest, opts ...grpc.CallOption) (*manager.SeedPeer, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateSeedPeer", varargs...)
ret0, _ := ret[0].(*manager.SeedPeer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UpdateSeedPeer indicates an expected call of UpdateSeedPeer.
func (mr *MockManagerClientMockRecorder) UpdateSeedPeer(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSeedPeer", reflect.TypeOf((*MockManagerClient)(nil).UpdateSeedPeer), varargs...)
}
// MockManager_KeepAliveClient is a mock of Manager_KeepAliveClient interface.
type MockManager_KeepAliveClient struct {
ctrl *gomock.Controller
recorder *MockManager_KeepAliveClientMockRecorder
}
// MockManager_KeepAliveClientMockRecorder is the mock recorder for MockManager_KeepAliveClient.
type MockManager_KeepAliveClientMockRecorder struct {
mock *MockManager_KeepAliveClient
}
// NewMockManager_KeepAliveClient creates a new mock instance.
func NewMockManager_KeepAliveClient(ctrl *gomock.Controller) *MockManager_KeepAliveClient {
mock := &MockManager_KeepAliveClient{ctrl: ctrl}
mock.recorder = &MockManager_KeepAliveClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager_KeepAliveClient) EXPECT() *MockManager_KeepAliveClientMockRecorder {
return m.recorder
}
// CloseAndRecv mocks base method.
func (m *MockManager_KeepAliveClient) CloseAndRecv() (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseAndRecv")
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// CloseAndRecv indicates an expected call of CloseAndRecv.
func (mr *MockManager_KeepAliveClientMockRecorder) CloseAndRecv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).CloseAndRecv))
}
// CloseSend mocks base method.
func (m *MockManager_KeepAliveClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockManager_KeepAliveClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockManager_KeepAliveClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockManager_KeepAliveClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).Context))
}
// Header mocks base method.
func (m *MockManager_KeepAliveClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockManager_KeepAliveClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).Header))
}
// RecvMsg mocks base method.
func (m_2 *MockManager_KeepAliveClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockManager_KeepAliveClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockManager_KeepAliveClient) Send(arg0 *manager.KeepAliveRequest) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockManager_KeepAliveClientMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).Send), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockManager_KeepAliveClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockManager_KeepAliveClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockManager_KeepAliveClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockManager_KeepAliveClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockManager_KeepAliveClient)(nil).Trailer))
}
// MockManagerServer is a mock of ManagerServer interface.
type MockManagerServer struct {
ctrl *gomock.Controller
recorder *MockManagerServerMockRecorder
}
// MockManagerServerMockRecorder is the mock recorder for MockManagerServer.
type MockManagerServerMockRecorder struct {
mock *MockManagerServer
}
// NewMockManagerServer creates a new mock instance.
func NewMockManagerServer(ctrl *gomock.Controller) *MockManagerServer {
mock := &MockManagerServer{ctrl: ctrl}
mock.recorder = &MockManagerServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManagerServer) EXPECT() *MockManagerServerMockRecorder {
return m.recorder
}
// GetObjectStorage mocks base method.
func (m *MockManagerServer) GetObjectStorage(arg0 context.Context, arg1 *manager.GetObjectStorageRequest) (*manager.ObjectStorage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetObjectStorage", arg0, arg1)
ret0, _ := ret[0].(*manager.ObjectStorage)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetObjectStorage indicates an expected call of GetObjectStorage.
func (mr *MockManagerServerMockRecorder) GetObjectStorage(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectStorage", reflect.TypeOf((*MockManagerServer)(nil).GetObjectStorage), arg0, arg1)
}
// GetScheduler mocks base method.
func (m *MockManagerServer) GetScheduler(arg0 context.Context, arg1 *manager.GetSchedulerRequest) (*manager.Scheduler, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetScheduler", arg0, arg1)
ret0, _ := ret[0].(*manager.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetScheduler indicates an expected call of GetScheduler.
func (mr *MockManagerServerMockRecorder) GetScheduler(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScheduler", reflect.TypeOf((*MockManagerServer)(nil).GetScheduler), arg0, arg1)
}
// GetSeedPeer mocks base method.
func (m *MockManagerServer) GetSeedPeer(arg0 context.Context, arg1 *manager.GetSeedPeerRequest) (*manager.SeedPeer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSeedPeer", arg0, arg1)
ret0, _ := ret[0].(*manager.SeedPeer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetSeedPeer indicates an expected call of GetSeedPeer.
func (mr *MockManagerServerMockRecorder) GetSeedPeer(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeer", reflect.TypeOf((*MockManagerServer)(nil).GetSeedPeer), arg0, arg1)
}
// KeepAlive mocks base method.
func (m *MockManagerServer) KeepAlive(arg0 manager.Manager_KeepAliveServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "KeepAlive", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// KeepAlive indicates an expected call of KeepAlive.
func (mr *MockManagerServerMockRecorder) KeepAlive(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeepAlive", reflect.TypeOf((*MockManagerServer)(nil).KeepAlive), arg0)
}
// ListBuckets mocks base method.
func (m *MockManagerServer) ListBuckets(arg0 context.Context, arg1 *manager.ListBucketsRequest) (*manager.ListBucketsResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListBuckets", arg0, arg1)
ret0, _ := ret[0].(*manager.ListBucketsResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListBuckets indicates an expected call of ListBuckets.
func (mr *MockManagerServerMockRecorder) ListBuckets(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockManagerServer)(nil).ListBuckets), arg0, arg1)
}
// ListSchedulers mocks base method.
func (m *MockManagerServer) ListSchedulers(arg0 context.Context, arg1 *manager.ListSchedulersRequest) (*manager.ListSchedulersResponse, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ListSchedulers", arg0, arg1)
ret0, _ := ret[0].(*manager.ListSchedulersResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ListSchedulers indicates an expected call of ListSchedulers.
func (mr *MockManagerServerMockRecorder) ListSchedulers(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSchedulers", reflect.TypeOf((*MockManagerServer)(nil).ListSchedulers), arg0, arg1)
}
// UpdateScheduler mocks base method.
func (m *MockManagerServer) UpdateScheduler(arg0 context.Context, arg1 *manager.UpdateSchedulerRequest) (*manager.Scheduler, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateScheduler", arg0, arg1)
ret0, _ := ret[0].(*manager.Scheduler)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UpdateScheduler indicates an expected call of UpdateScheduler.
func (mr *MockManagerServerMockRecorder) UpdateScheduler(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScheduler", reflect.TypeOf((*MockManagerServer)(nil).UpdateScheduler), arg0, arg1)
}
// UpdateSeedPeer mocks base method.
func (m *MockManagerServer) UpdateSeedPeer(arg0 context.Context, arg1 *manager.UpdateSeedPeerRequest) (*manager.SeedPeer, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdateSeedPeer", arg0, arg1)
ret0, _ := ret[0].(*manager.SeedPeer)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// UpdateSeedPeer indicates an expected call of UpdateSeedPeer.
func (mr *MockManagerServerMockRecorder) UpdateSeedPeer(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSeedPeer", reflect.TypeOf((*MockManagerServer)(nil).UpdateSeedPeer), arg0, arg1)
}
// MockManager_KeepAliveServer is a mock of Manager_KeepAliveServer interface.
type MockManager_KeepAliveServer struct {
ctrl *gomock.Controller
recorder *MockManager_KeepAliveServerMockRecorder
}
// MockManager_KeepAliveServerMockRecorder is the mock recorder for MockManager_KeepAliveServer.
type MockManager_KeepAliveServerMockRecorder struct {
mock *MockManager_KeepAliveServer
}
// NewMockManager_KeepAliveServer creates a new mock instance.
func NewMockManager_KeepAliveServer(ctrl *gomock.Controller) *MockManager_KeepAliveServer {
mock := &MockManager_KeepAliveServer{ctrl: ctrl}
mock.recorder = &MockManager_KeepAliveServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager_KeepAliveServer) EXPECT() *MockManager_KeepAliveServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockManager_KeepAliveServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockManager_KeepAliveServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).Context))
}
// Recv mocks base method.
func (m *MockManager_KeepAliveServer) Recv() (*manager.KeepAliveRequest, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*manager.KeepAliveRequest)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockManager_KeepAliveServerMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockManager_KeepAliveServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockManager_KeepAliveServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).RecvMsg), m)
}
// SendAndClose mocks base method.
func (m *MockManager_KeepAliveServer) SendAndClose(arg0 *emptypb.Empty) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendAndClose", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendAndClose indicates an expected call of SendAndClose.
func (mr *MockManager_KeepAliveServerMockRecorder) SendAndClose(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).SendAndClose), arg0)
}
// SendHeader mocks base method.
func (m *MockManager_KeepAliveServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockManager_KeepAliveServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockManager_KeepAliveServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockManager_KeepAliveServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockManager_KeepAliveServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockManager_KeepAliveServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockManager_KeepAliveServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockManager_KeepAliveServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockManager_KeepAliveServer)(nil).SetTrailer), arg0)
}

47
pkg/rpc/scheduler/client/client.go
View File

@ -25,32 +25,33 @@ import (
"google.golang.org/grpc"
commonv1 "d7y.io/api/pkg/apis/common/v1"
schedulerv1 "d7y.io/api/pkg/apis/scheduler/v1"
logger "d7y.io/dragonfly/v2/internal/dflog"
"d7y.io/dragonfly/v2/pkg/dfnet"
"d7y.io/dragonfly/v2/pkg/rpc"
"d7y.io/dragonfly/v2/pkg/rpc/base"
"d7y.io/dragonfly/v2/pkg/rpc/base/common"
"d7y.io/dragonfly/v2/pkg/rpc/scheduler"
"d7y.io/dragonfly/v2/pkg/rpc/common"
)
// NewBeginOfPiece creates begin of piece.
func NewBeginOfPiece(taskID, peerID string) *scheduler.PieceResult {
return &scheduler.PieceResult{
func NewBeginOfPiece(taskID, peerID string) *schedulerv1.PieceResult {
return &schedulerv1.PieceResult{
TaskId: taskID,
SrcPid: peerID,
PieceInfo: &base.PieceInfo{
PieceInfo: &commonv1.PieceInfo{
PieceNum: common.BeginOfPiece,
},
}
}
// NewBeginOfPiece creates end of piece.
func NewEndOfPiece(taskID, peerID string, finishedCount int32) *scheduler.PieceResult {
return &scheduler.PieceResult{
func NewEndOfPiece(taskID, peerID string, finishedCount int32) *schedulerv1.PieceResult {
return &schedulerv1.PieceResult{
TaskId: taskID,
SrcPid: peerID,
FinishedCount: finishedCount,
PieceInfo: &base.PieceInfo{
PieceInfo: &commonv1.PieceInfo{
PieceNum: common.EndOfPiece,
},
}
@ -74,22 +75,22 @@ func GetClientByAddr(addrs []dfnet.NetAddr, opts ...grpc.DialOption) (Client, er
// Client is the interface for grpc client.
type Client interface {
// RegisterPeerTask registers a peer into task.
RegisterPeerTask(context.Context, *scheduler.PeerTaskRequest, ...grpc.CallOption) (*scheduler.RegisterResult, error)
RegisterPeerTask(context.Context, *schedulerv1.PeerTaskRequest, ...grpc.CallOption) (*schedulerv1.RegisterResult, error)
// ReportPieceResult reports piece results and receives peer packets.
ReportPieceResult(context.Context, *scheduler.PeerTaskRequest, ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error)
ReportPieceResult(context.Context, *schedulerv1.PeerTaskRequest, ...grpc.CallOption) (schedulerv1.Scheduler_ReportPieceResultClient, error)
// ReportPeerResult reports downloading result for the peer.
ReportPeerResult(context.Context, *scheduler.PeerResult, ...grpc.CallOption) error
ReportPeerResult(context.Context, *schedulerv1.PeerResult, ...grpc.CallOption) error
// LeaveTask makes the peer leaving from task.
LeaveTask(context.Context, *scheduler.PeerTarget, ...grpc.CallOption) error
LeaveTask(context.Context, *schedulerv1.PeerTarget, ...grpc.CallOption) error
// Checks if any peer has the given task.
StatTask(context.Context, *scheduler.StatTaskRequest, ...grpc.CallOption) (*scheduler.Task, error)
StatTask(context.Context, *schedulerv1.StatTaskRequest, ...grpc.CallOption) (*schedulerv1.Task, error)
// A peer announces that it has the announced task to other peers.
AnnounceTask(context.Context, *scheduler.AnnounceTaskRequest, ...grpc.CallOption) error
AnnounceTask(context.Context, *schedulerv1.AnnounceTaskRequest, ...grpc.CallOption) error
// Update grpc addresses.
UpdateState([]dfnet.NetAddr)
@ -107,17 +108,17 @@ type client struct {
}
// getClient gets scheduler client with hashkey.
func (sc *client) getClient(key string, stick bool) (scheduler.SchedulerClient, string, error) {
func (sc *client) getClient(key string, stick bool) (schedulerv1.SchedulerClient, string, error) {
clientConn, err := sc.Connection.GetClientConn(key, stick)
if err != nil {
return nil, "", err
}
return scheduler.NewSchedulerClient(clientConn), clientConn.Target(), nil
return schedulerv1.NewSchedulerClient(clientConn), clientConn.Target(), nil
}
// RegisterPeerTask registers a peer into task.
func (sc *client) RegisterPeerTask(ctx context.Context, req *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (*scheduler.RegisterResult, error) {
func (sc *client) RegisterPeerTask(ctx context.Context, req *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (*schedulerv1.RegisterResult, error) {
// Generate task id.
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
@ -134,7 +135,7 @@ func (sc *client) RegisterPeerTask(ctx context.Context, req *scheduler.PeerTaskR
}
// ReportPieceResult reports piece results and receives peer packets.
func (sc *client) ReportPieceResult(ctx context.Context, req *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error) {
func (sc *client) ReportPieceResult(ctx context.Context, req *schedulerv1.PeerTaskRequest, opts ...grpc.CallOption) (schedulerv1.Scheduler_ReportPieceResultClient, error) {
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
return nil, err
@ -150,7 +151,7 @@ func (sc *client) ReportPieceResult(ctx context.Context, req *scheduler.PeerTask
}
// ReportPeerResult reports downloading result for the peer.
func (sc *client) ReportPeerResult(ctx context.Context, req *scheduler.PeerResult, opts ...grpc.CallOption) error {
func (sc *client) ReportPeerResult(ctx context.Context, req *schedulerv1.PeerResult, opts ...grpc.CallOption) error {
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
return err
@ -165,7 +166,7 @@ func (sc *client) ReportPeerResult(ctx context.Context, req *scheduler.PeerResul
}
// LeaveTask makes the peer leaving from task.
func (sc *client) LeaveTask(ctx context.Context, req *scheduler.PeerTarget, opts ...grpc.CallOption) error {
func (sc *client) LeaveTask(ctx context.Context, req *schedulerv1.PeerTarget, opts ...grpc.CallOption) error {
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
return err
@ -180,7 +181,7 @@ func (sc *client) LeaveTask(ctx context.Context, req *scheduler.PeerTarget, opts
}
// Checks if any peer has the given task.
func (sc *client) StatTask(ctx context.Context, req *scheduler.StatTaskRequest, opts ...grpc.CallOption) (*scheduler.Task, error) {
func (sc *client) StatTask(ctx context.Context, req *schedulerv1.StatTaskRequest, opts ...grpc.CallOption) (*schedulerv1.Task, error) {
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
return nil, err
@ -196,7 +197,7 @@ func (sc *client) StatTask(ctx context.Context, req *scheduler.StatTaskRequest,
}
// A peer announces that it has the announced task to other peers.
func (sc *client) AnnounceTask(ctx context.Context, req *scheduler.AnnounceTaskRequest, opts ...grpc.CallOption) error {
func (sc *client) AnnounceTask(ctx context.Context, req *schedulerv1.AnnounceTaskRequest, opts ...grpc.CallOption) error {
client, target, err := sc.getClient(req.TaskId, false)
if err != nil {
return err

20
pkg/rpc/scheduler/client/mocks/client_mock.go
View File

@ -8,8 +8,8 @@ import (
context "context"
reflect "reflect"
v1 "d7y.io/api/pkg/apis/scheduler/v1"
dfnet "d7y.io/dragonfly/v2/pkg/dfnet"
scheduler "d7y.io/dragonfly/v2/pkg/rpc/scheduler"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
)
@ -38,7 +38,7 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder {
}
// AnnounceTask mocks base method.
func (m *MockClient) AnnounceTask(arg0 context.Context, arg1 *scheduler.AnnounceTaskRequest, arg2 ...grpc.CallOption) error {
func (m *MockClient) AnnounceTask(arg0 context.Context, arg1 *v1.AnnounceTaskRequest, arg2 ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
@ -85,7 +85,7 @@ func (mr *MockClientMockRecorder) GetState() *gomock.Call {
}
// LeaveTask mocks base method.
func (m *MockClient) LeaveTask(arg0 context.Context, arg1 *scheduler.PeerTarget, arg2 ...grpc.CallOption) error {
func (m *MockClient) LeaveTask(arg0 context.Context, arg1 *v1.PeerTarget, arg2 ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
@ -104,14 +104,14 @@ func (mr *MockClientMockRecorder) LeaveTask(arg0, arg1 interface{}, arg2 ...inte
}
// RegisterPeerTask mocks base method.
func (m *MockClient) RegisterPeerTask(arg0 context.Context, arg1 *scheduler.PeerTaskRequest, arg2 ...grpc.CallOption) (*scheduler.RegisterResult, error) {
func (m *MockClient) RegisterPeerTask(arg0 context.Context, arg1 *v1.PeerTaskRequest, arg2 ...grpc.CallOption) (*v1.RegisterResult, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "RegisterPeerTask", varargs...)
ret0, _ := ret[0].(*scheduler.RegisterResult)
ret0, _ := ret[0].(*v1.RegisterResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -124,7 +124,7 @@ func (mr *MockClientMockRecorder) RegisterPeerTask(arg0, arg1 interface{}, arg2
}
// ReportPeerResult mocks base method.
func (m *MockClient) ReportPeerResult(arg0 context.Context, arg1 *scheduler.PeerResult, arg2 ...grpc.CallOption) error {
func (m *MockClient) ReportPeerResult(arg0 context.Context, arg1 *v1.PeerResult, arg2 ...grpc.CallOption) error {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
@ -143,14 +143,14 @@ func (mr *MockClientMockRecorder) ReportPeerResult(arg0, arg1 interface{}, arg2
}
// ReportPieceResult mocks base method.
func (m *MockClient) ReportPieceResult(arg0 context.Context, arg1 *scheduler.PeerTaskRequest, arg2 ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error) {
func (m *MockClient) ReportPieceResult(arg0 context.Context, arg1 *v1.PeerTaskRequest, arg2 ...grpc.CallOption) (v1.Scheduler_ReportPieceResultClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ReportPieceResult", varargs...)
ret0, _ := ret[0].(scheduler.Scheduler_ReportPieceResultClient)
ret0, _ := ret[0].(v1.Scheduler_ReportPieceResultClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -163,14 +163,14 @@ func (mr *MockClientMockRecorder) ReportPieceResult(arg0, arg1 interface{}, arg2
}
// StatTask mocks base method.
func (m *MockClient) StatTask(arg0 context.Context, arg1 *scheduler.StatTaskRequest, arg2 ...grpc.CallOption) (*scheduler.Task, error) {
func (m *MockClient) StatTask(arg0 context.Context, arg1 *v1.StatTaskRequest, arg2 ...grpc.CallOption) (*v1.Task, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "StatTask", varargs...)
ret0, _ := ret[0].(*scheduler.Task)
ret0, _ := ret[0].(*v1.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
}

647
pkg/rpc/scheduler/mocks/scheduler_mock.go
View File

@ -1,647 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: scheduler/scheduler.pb.go
// Package mocks is a generated GoMock package.
package mocks
import (
context "context"
reflect "reflect"
scheduler "d7y.io/dragonfly/v2/pkg/rpc/scheduler"
gomock "github.com/golang/mock/gomock"
grpc "google.golang.org/grpc"
metadata "google.golang.org/grpc/metadata"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// MockisRegisterResult_DirectPiece is a mock of isRegisterResult_DirectPiece interface.
type MockisRegisterResult_DirectPiece struct {
ctrl *gomock.Controller
recorder *MockisRegisterResult_DirectPieceMockRecorder
}
// MockisRegisterResult_DirectPieceMockRecorder is the mock recorder for MockisRegisterResult_DirectPiece.
type MockisRegisterResult_DirectPieceMockRecorder struct {
mock *MockisRegisterResult_DirectPiece
}
// NewMockisRegisterResult_DirectPiece creates a new mock instance.
func NewMockisRegisterResult_DirectPiece(ctrl *gomock.Controller) *MockisRegisterResult_DirectPiece {
mock := &MockisRegisterResult_DirectPiece{ctrl: ctrl}
mock.recorder = &MockisRegisterResult_DirectPieceMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisRegisterResult_DirectPiece) EXPECT() *MockisRegisterResult_DirectPieceMockRecorder {
return m.recorder
}
// isRegisterResult_DirectPiece mocks base method.
func (m *MockisRegisterResult_DirectPiece) isRegisterResult_DirectPiece() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "isRegisterResult_DirectPiece")
}
// isRegisterResult_DirectPiece indicates an expected call of isRegisterResult_DirectPiece.
func (mr *MockisRegisterResult_DirectPieceMockRecorder) isRegisterResult_DirectPiece() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isRegisterResult_DirectPiece", reflect.TypeOf((*MockisRegisterResult_DirectPiece)(nil).isRegisterResult_DirectPiece))
}
// MockisPeerPacket_ErrorDetail is a mock of isPeerPacket_ErrorDetail interface.
type MockisPeerPacket_ErrorDetail struct {
ctrl *gomock.Controller
recorder *MockisPeerPacket_ErrorDetailMockRecorder
}
// MockisPeerPacket_ErrorDetailMockRecorder is the mock recorder for MockisPeerPacket_ErrorDetail.
type MockisPeerPacket_ErrorDetailMockRecorder struct {
mock *MockisPeerPacket_ErrorDetail
}
// NewMockisPeerPacket_ErrorDetail creates a new mock instance.
func NewMockisPeerPacket_ErrorDetail(ctrl *gomock.Controller) *MockisPeerPacket_ErrorDetail {
mock := &MockisPeerPacket_ErrorDetail{ctrl: ctrl}
mock.recorder = &MockisPeerPacket_ErrorDetailMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisPeerPacket_ErrorDetail) EXPECT() *MockisPeerPacket_ErrorDetailMockRecorder {
return m.recorder
}
// isPeerPacket_ErrorDetail mocks base method.
func (m *MockisPeerPacket_ErrorDetail) isPeerPacket_ErrorDetail() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "isPeerPacket_ErrorDetail")
}
// isPeerPacket_ErrorDetail indicates an expected call of isPeerPacket_ErrorDetail.
func (mr *MockisPeerPacket_ErrorDetailMockRecorder) isPeerPacket_ErrorDetail() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isPeerPacket_ErrorDetail", reflect.TypeOf((*MockisPeerPacket_ErrorDetail)(nil).isPeerPacket_ErrorDetail))
}
// MockisPeerResult_ErrorDetail is a mock of isPeerResult_ErrorDetail interface.
type MockisPeerResult_ErrorDetail struct {
ctrl *gomock.Controller
recorder *MockisPeerResult_ErrorDetailMockRecorder
}
// MockisPeerResult_ErrorDetailMockRecorder is the mock recorder for MockisPeerResult_ErrorDetail.
type MockisPeerResult_ErrorDetailMockRecorder struct {
mock *MockisPeerResult_ErrorDetail
}
// NewMockisPeerResult_ErrorDetail creates a new mock instance.
func NewMockisPeerResult_ErrorDetail(ctrl *gomock.Controller) *MockisPeerResult_ErrorDetail {
mock := &MockisPeerResult_ErrorDetail{ctrl: ctrl}
mock.recorder = &MockisPeerResult_ErrorDetailMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisPeerResult_ErrorDetail) EXPECT() *MockisPeerResult_ErrorDetailMockRecorder {
return m.recorder
}
// isPeerResult_ErrorDetail mocks base method.
func (m *MockisPeerResult_ErrorDetail) isPeerResult_ErrorDetail() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "isPeerResult_ErrorDetail")
}
// isPeerResult_ErrorDetail indicates an expected call of isPeerResult_ErrorDetail.
func (mr *MockisPeerResult_ErrorDetailMockRecorder) isPeerResult_ErrorDetail() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isPeerResult_ErrorDetail", reflect.TypeOf((*MockisPeerResult_ErrorDetail)(nil).isPeerResult_ErrorDetail))
}
// MockSchedulerClient is a mock of SchedulerClient interface.
type MockSchedulerClient struct {
ctrl *gomock.Controller
recorder *MockSchedulerClientMockRecorder
}
// MockSchedulerClientMockRecorder is the mock recorder for MockSchedulerClient.
type MockSchedulerClientMockRecorder struct {
mock *MockSchedulerClient
}
// NewMockSchedulerClient creates a new mock instance.
func NewMockSchedulerClient(ctrl *gomock.Controller) *MockSchedulerClient {
mock := &MockSchedulerClient{ctrl: ctrl}
mock.recorder = &MockSchedulerClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSchedulerClient) EXPECT() *MockSchedulerClientMockRecorder {
return m.recorder
}
// AnnounceTask mocks base method.
func (m *MockSchedulerClient) AnnounceTask(ctx context.Context, in *scheduler.AnnounceTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "AnnounceTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AnnounceTask indicates an expected call of AnnounceTask.
func (mr *MockSchedulerClientMockRecorder) AnnounceTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceTask", reflect.TypeOf((*MockSchedulerClient)(nil).AnnounceTask), varargs...)
}
// LeaveTask mocks base method.
func (m *MockSchedulerClient) LeaveTask(ctx context.Context, in *scheduler.PeerTarget, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "LeaveTask", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LeaveTask indicates an expected call of LeaveTask.
func (mr *MockSchedulerClientMockRecorder) LeaveTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaveTask", reflect.TypeOf((*MockSchedulerClient)(nil).LeaveTask), varargs...)
}
// RegisterPeerTask mocks base method.
func (m *MockSchedulerClient) RegisterPeerTask(ctx context.Context, in *scheduler.PeerTaskRequest, opts ...grpc.CallOption) (*scheduler.RegisterResult, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "RegisterPeerTask", varargs...)
ret0, _ := ret[0].(*scheduler.RegisterResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RegisterPeerTask indicates an expected call of RegisterPeerTask.
func (mr *MockSchedulerClientMockRecorder) RegisterPeerTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerTask", reflect.TypeOf((*MockSchedulerClient)(nil).RegisterPeerTask), varargs...)
}
// ReportPeerResult mocks base method.
func (m *MockSchedulerClient) ReportPeerResult(ctx context.Context, in *scheduler.PeerResult, opts ...grpc.CallOption) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ReportPeerResult", varargs...)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReportPeerResult indicates an expected call of ReportPeerResult.
func (mr *MockSchedulerClientMockRecorder) ReportPeerResult(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeerResult", reflect.TypeOf((*MockSchedulerClient)(nil).ReportPeerResult), varargs...)
}
// ReportPieceResult mocks base method.
func (m *MockSchedulerClient) ReportPieceResult(ctx context.Context, opts ...grpc.CallOption) (scheduler.Scheduler_ReportPieceResultClient, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ReportPieceResult", varargs...)
ret0, _ := ret[0].(scheduler.Scheduler_ReportPieceResultClient)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReportPieceResult indicates an expected call of ReportPieceResult.
func (mr *MockSchedulerClientMockRecorder) ReportPieceResult(ctx interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPieceResult", reflect.TypeOf((*MockSchedulerClient)(nil).ReportPieceResult), varargs...)
}
// StatTask mocks base method.
func (m *MockSchedulerClient) StatTask(ctx context.Context, in *scheduler.StatTaskRequest, opts ...grpc.CallOption) (*scheduler.Task, error) {
m.ctrl.T.Helper()
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "StatTask", varargs...)
ret0, _ := ret[0].(*scheduler.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StatTask indicates an expected call of StatTask.
func (mr *MockSchedulerClientMockRecorder) StatTask(ctx, in interface{}, opts ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockSchedulerClient)(nil).StatTask), varargs...)
}
// MockScheduler_ReportPieceResultClient is a mock of Scheduler_ReportPieceResultClient interface.
type MockScheduler_ReportPieceResultClient struct {
ctrl *gomock.Controller
recorder *MockScheduler_ReportPieceResultClientMockRecorder
}
// MockScheduler_ReportPieceResultClientMockRecorder is the mock recorder for MockScheduler_ReportPieceResultClient.
type MockScheduler_ReportPieceResultClientMockRecorder struct {
mock *MockScheduler_ReportPieceResultClient
}
// NewMockScheduler_ReportPieceResultClient creates a new mock instance.
func NewMockScheduler_ReportPieceResultClient(ctrl *gomock.Controller) *MockScheduler_ReportPieceResultClient {
mock := &MockScheduler_ReportPieceResultClient{ctrl: ctrl}
mock.recorder = &MockScheduler_ReportPieceResultClientMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScheduler_ReportPieceResultClient) EXPECT() *MockScheduler_ReportPieceResultClientMockRecorder {
return m.recorder
}
// CloseSend mocks base method.
func (m *MockScheduler_ReportPieceResultClient) CloseSend() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CloseSend")
ret0, _ := ret[0].(error)
return ret0
}
// CloseSend indicates an expected call of CloseSend.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) CloseSend() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).CloseSend))
}
// Context mocks base method.
func (m *MockScheduler_ReportPieceResultClient) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).Context))
}
// Header mocks base method.
func (m *MockScheduler_ReportPieceResultClient) Header() (metadata.MD, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(metadata.MD)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Header indicates an expected call of Header.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).Header))
}
// Recv mocks base method.
func (m *MockScheduler_ReportPieceResultClient) Recv() (*scheduler.PeerPacket, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*scheduler.PeerPacket)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockScheduler_ReportPieceResultClient) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockScheduler_ReportPieceResultClient) Send(arg0 *scheduler.PieceResult) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).Send), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockScheduler_ReportPieceResultClient) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).SendMsg), m)
}
// Trailer mocks base method.
func (m *MockScheduler_ReportPieceResultClient) Trailer() metadata.MD {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Trailer")
ret0, _ := ret[0].(metadata.MD)
return ret0
}
// Trailer indicates an expected call of Trailer.
func (mr *MockScheduler_ReportPieceResultClientMockRecorder) Trailer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockScheduler_ReportPieceResultClient)(nil).Trailer))
}
// MockSchedulerServer is a mock of SchedulerServer interface.
type MockSchedulerServer struct {
ctrl *gomock.Controller
recorder *MockSchedulerServerMockRecorder
}
// MockSchedulerServerMockRecorder is the mock recorder for MockSchedulerServer.
type MockSchedulerServerMockRecorder struct {
mock *MockSchedulerServer
}
// NewMockSchedulerServer creates a new mock instance.
func NewMockSchedulerServer(ctrl *gomock.Controller) *MockSchedulerServer {
mock := &MockSchedulerServer{ctrl: ctrl}
mock.recorder = &MockSchedulerServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSchedulerServer) EXPECT() *MockSchedulerServerMockRecorder {
return m.recorder
}
// AnnounceTask mocks base method.
func (m *MockSchedulerServer) AnnounceTask(arg0 context.Context, arg1 *scheduler.AnnounceTaskRequest) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AnnounceTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// AnnounceTask indicates an expected call of AnnounceTask.
func (mr *MockSchedulerServerMockRecorder) AnnounceTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceTask", reflect.TypeOf((*MockSchedulerServer)(nil).AnnounceTask), arg0, arg1)
}
// LeaveTask mocks base method.
func (m *MockSchedulerServer) LeaveTask(arg0 context.Context, arg1 *scheduler.PeerTarget) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LeaveTask", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// LeaveTask indicates an expected call of LeaveTask.
func (mr *MockSchedulerServerMockRecorder) LeaveTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaveTask", reflect.TypeOf((*MockSchedulerServer)(nil).LeaveTask), arg0, arg1)
}
// RegisterPeerTask mocks base method.
func (m *MockSchedulerServer) RegisterPeerTask(arg0 context.Context, arg1 *scheduler.PeerTaskRequest) (*scheduler.RegisterResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "RegisterPeerTask", arg0, arg1)
ret0, _ := ret[0].(*scheduler.RegisterResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// RegisterPeerTask indicates an expected call of RegisterPeerTask.
func (mr *MockSchedulerServerMockRecorder) RegisterPeerTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterPeerTask", reflect.TypeOf((*MockSchedulerServer)(nil).RegisterPeerTask), arg0, arg1)
}
// ReportPeerResult mocks base method.
func (m *MockSchedulerServer) ReportPeerResult(arg0 context.Context, arg1 *scheduler.PeerResult) (*emptypb.Empty, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReportPeerResult", arg0, arg1)
ret0, _ := ret[0].(*emptypb.Empty)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// ReportPeerResult indicates an expected call of ReportPeerResult.
func (mr *MockSchedulerServerMockRecorder) ReportPeerResult(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPeerResult", reflect.TypeOf((*MockSchedulerServer)(nil).ReportPeerResult), arg0, arg1)
}
// ReportPieceResult mocks base method.
func (m *MockSchedulerServer) ReportPieceResult(arg0 scheduler.Scheduler_ReportPieceResultServer) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ReportPieceResult", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// ReportPieceResult indicates an expected call of ReportPieceResult.
func (mr *MockSchedulerServerMockRecorder) ReportPieceResult(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportPieceResult", reflect.TypeOf((*MockSchedulerServer)(nil).ReportPieceResult), arg0)
}
// StatTask mocks base method.
func (m *MockSchedulerServer) StatTask(arg0 context.Context, arg1 *scheduler.StatTaskRequest) (*scheduler.Task, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "StatTask", arg0, arg1)
ret0, _ := ret[0].(*scheduler.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// StatTask indicates an expected call of StatTask.
func (mr *MockSchedulerServerMockRecorder) StatTask(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatTask", reflect.TypeOf((*MockSchedulerServer)(nil).StatTask), arg0, arg1)
}
// MockScheduler_ReportPieceResultServer is a mock of Scheduler_ReportPieceResultServer interface.
type MockScheduler_ReportPieceResultServer struct {
ctrl *gomock.Controller
recorder *MockScheduler_ReportPieceResultServerMockRecorder
}
// MockScheduler_ReportPieceResultServerMockRecorder is the mock recorder for MockScheduler_ReportPieceResultServer.
type MockScheduler_ReportPieceResultServerMockRecorder struct {
mock *MockScheduler_ReportPieceResultServer
}
// NewMockScheduler_ReportPieceResultServer creates a new mock instance.
func NewMockScheduler_ReportPieceResultServer(ctrl *gomock.Controller) *MockScheduler_ReportPieceResultServer {
mock := &MockScheduler_ReportPieceResultServer{ctrl: ctrl}
mock.recorder = &MockScheduler_ReportPieceResultServerMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockScheduler_ReportPieceResultServer) EXPECT() *MockScheduler_ReportPieceResultServerMockRecorder {
return m.recorder
}
// Context mocks base method.
func (m *MockScheduler_ReportPieceResultServer) Context() context.Context {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(context.Context)
return ret0
}
// Context indicates an expected call of Context.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).Context))
}
// Recv mocks base method.
func (m *MockScheduler_ReportPieceResultServer) Recv() (*scheduler.PieceResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Recv")
ret0, _ := ret[0].(*scheduler.PieceResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Recv indicates an expected call of Recv.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) Recv() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).Recv))
}
// RecvMsg mocks base method.
func (m_2 *MockScheduler_ReportPieceResultServer) RecvMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).RecvMsg), m)
}
// Send mocks base method.
func (m *MockScheduler_ReportPieceResultServer) Send(arg0 *scheduler.PeerPacket) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// Send indicates an expected call of Send.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).Send), arg0)
}
// SendHeader mocks base method.
func (m *MockScheduler_ReportPieceResultServer) SendHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SendHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SendHeader indicates an expected call of SendHeader.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).SendHeader), arg0)
}
// SendMsg mocks base method.
func (m_2 *MockScheduler_ReportPieceResultServer) SendMsg(m interface{}) error {
m_2.ctrl.T.Helper()
ret := m_2.ctrl.Call(m_2, "SendMsg", m)
ret0, _ := ret[0].(error)
return ret0
}
// SendMsg indicates an expected call of SendMsg.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).SendMsg), m)
}
// SetHeader mocks base method.
func (m *MockScheduler_ReportPieceResultServer) SetHeader(arg0 metadata.MD) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeader", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeader indicates an expected call of SetHeader.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).SetHeader), arg0)
}
// SetTrailer mocks base method.
func (m *MockScheduler_ReportPieceResultServer) SetTrailer(arg0 metadata.MD) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "SetTrailer", arg0)
}
// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockScheduler_ReportPieceResultServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockScheduler_ReportPieceResultServer)(nil).SetTrailer), arg0)
}

2094
pkg/rpc/scheduler/scheduler.pb.go
View File

File diff suppressed because it is too large Load Diff

1384
pkg/rpc/scheduler/scheduler.pb.validate.go
View File

File diff suppressed because it is too large Load Diff

257
pkg/rpc/scheduler/scheduler.proto
View File

@ -1,257 +0,0 @@
/*
* Copyright 2020 The Dragonfly Authors
*
* Licensed 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.
*/
syntax = "proto3";
package scheduler;
import "pkg/rpc/base/base.proto";
import "pkg/rpc/errordetails/error_details.proto";
import "validate/validate.proto";
import "google/protobuf/empty.proto";
option go_package = "d7y.io/dragonfly/v2/pkg/rpc/scheduler";
// PeerTaskRequest represents request of RegisterPeerTask.
message PeerTaskRequest{
// Download url.
string url = 1 [(validate.rules).string.uri = true];
// URL meta info.
base.UrlMeta url_meta = 2 [(validate.rules).message.required = true];
// Peer id and it must be global uniqueness.
string peer_id = 3 [(validate.rules).string.min_len = 1];
// Peer host info.
PeerHost peer_host = 4;
// Peer host load.
base.HostLoad host_load = 5;
// Whether this request is caused by migration.
bool is_migrating = 6;
// Pattern includes p2p, seed-peer and source.
base.Pattern pattern = 7;
// Task id.
string task_id = 8;
}
// RegisterResult represents response of RegisterPeerTask.
message RegisterResult{
// Task type.
base.TaskType task_type = 1;
// Task id
string task_id = 2 [(validate.rules).string.min_len = 1];
// File size scope.
base.SizeScope size_scope = 3 [(validate.rules).enum.defined_only = true];
// Download the only piece directly for small or tiny file.
oneof direct_piece{
// Return single piece info when size scope is small.
SinglePiece single_piece = 4;
// Return task content when size scope is tiny.
bytes piece_content = 5;
}
// Task extend attribute,
// only direct_piece will carry extend attribute.
base.ExtendAttribute extend_attribute = 6;
}
// SinglePiece represents information of single piece.
message SinglePiece{
// Destination peer id.
string dst_pid = 1 [(validate.rules).string.min_len = 1];
// Destination download address.
string dst_addr = 2 [(validate.rules).string.min_len = 1];
// Piece info.
base.PieceInfo piece_info = 3;
}
// PeerHost represents information of peer host.
message PeerHost{
// Peer host id.
string id = 1 [(validate.rules).string.min_len = 1];
// peer host ip
string ip = 2 [(validate.rules).string.ip = true];
// Port of grpc service.
int32 rpc_port = 3 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// Port of download server.
int32 down_port = 4 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// Peer hostname.
string host_name = 5 [(validate.rules).string.hostname = true];
// Security domain for network.
string security_domain = 6;
// Location path(area|country|province|city|...).
string location = 7;
// IDC where the peer host is located
string idc = 8;
// Network topology(switch|router|...).
string net_topology = 9;
}
// PieceResult represents request of ReportPieceResult.
message PieceResult{
// Task id.
string task_id = 1 [(validate.rules).string.min_len = 1];
// Source peer id.
string src_pid = 2 [(validate.rules).string.min_len = 1];
// Destination peer id.
string dst_pid = 3;
// Piece info.
base.PieceInfo piece_info = 4;
// Begin time of the piece downloading.
uint64 begin_time = 5;
// End time of the piece downloading.
uint64 end_time = 6;
// Whether the piece downloading is successfully.
bool success = 7;
// Result code.
base.Code code = 8;
// Peer host load.
base.HostLoad host_load = 9;
// Finished count.
int32 finished_count = 10;
// Task extend attribute,
// only first success back source piece will carry extend attribute.
base.ExtendAttribute extend_attribute = 11;
}
// PeerPacket represents response of ReportPieceResult.
message PeerPacket{
message DestPeer{
// Destination ip.
string ip = 1 [(validate.rules).string.ip = true];
// Port of grpc service.
int32 rpc_port = 2 [(validate.rules).int32 = {gte: 1024, lt: 65535}];
// Destination peer id.
string peer_id = 3 [(validate.rules).string.min_len = 1];
}
// Task id.
string task_id = 2 [(validate.rules).string.min_len = 1];
// Source peer id.
string src_pid = 3 [(validate.rules).string.min_len = 1];
// Concurrent downloading count from main peer.
int32 parallel_count = 4 [(validate.rules).int32.gte = 1];
// Main peer.
DestPeer main_peer = 5;
// Candidate peers.
repeated DestPeer candidate_peers = 6;
// Result code.
base.Code code = 7;
// Error detail.
oneof error_detail{
// Source error.
errordetails.SourceError source_error = 8;
}
}
// PeerResult represents response of ReportPeerResult.
message PeerResult{
// Task id.
string task_id = 1 [(validate.rules).string.min_len = 1];
// Peer id.
string peer_id = 2 [(validate.rules).string.min_len = 1];
// Source host ip.
string src_ip = 3 [(validate.rules).string.ip = true];
// Security domain.
string security_domain = 4;
// IDC where the peer host is located
string idc = 5;
// Download url.
string url = 6 [(validate.rules).string.uri = true];
// Total content length.
int64 content_length = 7 [(validate.rules).int64.gte = -1];
// Total network traffic.
uint64 traffic = 8;
// Total cost time.
uint32 cost = 9;
// Whether peer downloading file is successfully.
bool success = 10;
// Result code.
base.Code code = 11;
// Task total piece count.
int32 total_piece_count = 12 [(validate.rules).int32.gte = -1];
// Error detail.
oneof error_detail{
// Source error.
errordetails.SourceError source_error = 13;
}
}
// PeerTarget represents request of LeaveTask.
message PeerTarget{
// Task id.
string task_id = 1 [(validate.rules).string.min_len = 1];
// Peer id.
string peer_id = 2 [(validate.rules).string.min_len = 1];
}
// StatTaskRequest represents request of StatTask.
message StatTaskRequest{
// Task id.
string task_id = 1 [(validate.rules).string.min_len = 1];
}
// Task represents download task.
message Task{
// Task id.
string id = 1 [(validate.rules).string.min_len = 1];
// Task type.
base.TaskType type = 2;
// Task content length.
int64 content_length = 3 [(validate.rules).int64.gte = 1];
// Task total piece count.
int32 total_piece_count = 4 [(validate.rules).int32.gte = 1];
// Task state.
string state = 5 [(validate.rules).string.min_len = 1];
// Task peer count.
int32 peer_count = 6 [(validate.rules).int32.gte = 0];
// Task contains available peer.
bool hasAvailablePeer = 7;
}
// AnnounceTaskRequest represents request of AnnounceTask.
message AnnounceTaskRequest{
// Task id.
string task_id = 1 [(validate.rules).string.min_len = 1];
// Download url.
string url = 2 [(validate.rules).string = {uri: true, ignore_empty: true}];
// URL meta info.
base.UrlMeta url_meta = 3 [(validate.rules).message.required = true];
// Peer host info.
PeerHost peer_host = 4;
// Task piece info.
base.PiecePacket piece_packet = 5 [(validate.rules).message.required = true];
// Task type.
base.TaskType task_type = 6;
}
// Scheduler RPC Service.
service Scheduler{
// RegisterPeerTask registers a peer into task.
rpc RegisterPeerTask(PeerTaskRequest)returns(RegisterResult);
// ReportPieceResult reports piece results and receives peer packets.
rpc ReportPieceResult(stream PieceResult)returns(stream PeerPacket);
// ReportPeerResult reports downloading result for the peer.
rpc ReportPeerResult(PeerResult)returns(google.protobuf.Empty);
// LeaveTask makes the peer leaving from task.
rpc LeaveTask(PeerTarget)returns(google.protobuf.Empty);
// Checks if any peer has the given task.
rpc StatTask(StatTaskRequest)returns(Task);
// A peer announces that it has the announced task to other peers.
rpc AnnounceTask(AnnounceTaskRequest) returns(google.protobuf.Empty);
}

Some files were not shown because too many files have changed in this diff Show More