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

feat: grpc dial adds context (#1594) 

Signed-off-by: Gaius <gaius.qi@gmail.com>
This commit is contained in:
Gaius 2022-08-25 21:16:29 +08:00
parent f5e8902656
commit ad553d949b
No known key found for this signature in database
GPG Key ID: 8B4E5D1290FA2FFB
14 changed files with 29 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/daemon/daemon.go
View File

@ -118,7 +118,7 @@ func New(opt *config.DaemonOption, d dfpath.Dfpath) (Daemon, error) {
if opt.Scheduler.Manager.Enable { if opt.Scheduler.Manager.Enable {
var err error var err error
managerClient, err = managerclient.GetClientByAddr(opt.Scheduler.Manager.NetAddrs) managerClient, err = managerclient.GetClientByAddr(context.Background(), opt.Scheduler.Manager.NetAddrs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -142,7 +142,7 @@ func New(opt *config.DaemonOption, d dfpath.Dfpath) (Daemon, error) {
} }
} }
sched, err := schedulerclient.GetClient(dynconfig) sched, err := schedulerclient.GetClient(context.Background(), dynconfig)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get schedulers: %w", err) return nil, fmt.Errorf("failed to get schedulers: %w", err)
} }

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

@ -171,7 +171,7 @@ func (poller *pieceTaskPoller) getPieceTasksByPeer(
Type: dfnet.TCP, Type: dfnet.TCP,
Addr: fmt.Sprintf("%s:%d", peer.Ip, peer.RpcPort), Addr: fmt.Sprintf("%s:%d", peer.Ip, peer.RpcPort),
} }
client, err := dfdaemonclient.GetClient(netAddr.String()) client, err := dfdaemonclient.GetClient(context.Background(), netAddr.String())
if err != nil { if err != nil {
ptc.Errorf("get dfdaemon client error: %s", err) ptc.Errorf("get dfdaemon client error: %s", err)
span.RecordError(err) span.RecordError(err)

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

@ -166,7 +166,7 @@ func (s *pieceTaskSyncManager) newPieceTaskSynchronizer(
Type: dfnet.TCP, Type: dfnet.TCP,
Addr: fmt.Sprintf("%s:%d", dstPeer.Ip, dstPeer.RpcPort), Addr: fmt.Sprintf("%s:%d", dstPeer.Ip, dstPeer.RpcPort),
} }
client, err := dfdaemonclient.GetClient(netAddr.String()) client, err := dfdaemonclient.GetClient(context.Background(), netAddr.String())
if err != nil { if err != nil {
s.peerTaskConductor.Errorf("get dfdaemon client error: %s, dest peer: %s", err, dstPeer.PeerId) s.peerTaskConductor.Errorf("get dfdaemon client error: %s, dest peer: %s", err, dstPeer.PeerId)
return err return err

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

@ -566,7 +566,7 @@ func setupPeerServerAndClient(t *testing.T, srv *server, assert *testifyassert.A
Type: dfnet.TCP, Type: dfnet.TCP,
Addr: fmt.Sprintf(":%d", port), Addr: fmt.Sprintf(":%d", port),
} }
client, err := dfdaemonclient.GetClient(netAddr.String()) client, err := dfdaemonclient.GetClient(context.Background(), netAddr.String())
assert.Nil(err, "grpc dial should be ok") assert.Nil(err, "grpc dial should be ok")
return client return client
} }

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

@ -379,7 +379,7 @@ func setupSeederServerAndClient(t *testing.T, srv *server, sd *seeder, assert *t
} }
}() }()
client, err := client.GetClientByAddr(dfnet.NetAddr{ client, err := client.GetClientByAddr(context.Background(), dfnet.NetAddr{
Type: dfnet.TCP, Type: dfnet.TCP,
Addr: fmt.Sprintf(":%d", port), Addr: fmt.Sprintf(":%d", port),
}) })

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

@ -173,7 +173,7 @@ func runDfcacheSubcmd(cmdName string, args []string) error {
// checkDaemon checks if daemon is running // checkDaemon checks if daemon is running
func checkDaemon(daemonSockPath string) (client.Client, error) { func checkDaemon(daemonSockPath string) (client.Client, error) {
netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: daemonSockPath} netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: daemonSockPath}
dfdaemonClient, err := client.GetClient(netAddr.String()) dfdaemonClient, err := client.GetClient(context.Background(), netAddr.String())
if err != nil { if err != nil {
return nil, err return nil, err
} }

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

@ -130,7 +130,7 @@ func initDaemonDfpath(cfg *config.DaemonOption) (dfpath.Dfpath, error) {
func runDaemon(d dfpath.Dfpath) error { func runDaemon(d dfpath.Dfpath) error {
logger.Infof("Version:\n%s", version.Version()) logger.Infof("Version:\n%s", version.Version())
netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: d.DaemonSockPath()} netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: d.DaemonSockPath()}
daemonClient, err := client.GetClient(netAddr.String()) daemonClient, err := client.GetClient(context.Background(), netAddr.String())
if err != nil { if err != nil {
return err return err
} }

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

@ -245,7 +245,7 @@ func runDfget(dfgetLockPath, daemonSockPath string) error {
// checkAndSpawnDaemon do checking at three checkpoints // checkAndSpawnDaemon do checking at three checkpoints
func checkAndSpawnDaemon(dfgetLockPath, daemonSockPath string) (client.Client, error) { func checkAndSpawnDaemon(dfgetLockPath, daemonSockPath string) (client.Client, error) {
netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: daemonSockPath} netAddr := &dfnet.NetAddr{Type: dfnet.UNIX, Addr: daemonSockPath}
dfdaemonClient, err := client.GetClient(netAddr.String()) dfdaemonClient, err := client.GetClient(context.Background(), netAddr.String())
if err != nil { if err != nil {
return nil, err return nil, err
} }

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

@ -54,8 +54,9 @@ const (
perRetryTimeout = 3 * time.Second perRetryTimeout = 3 * time.Second
) )
func GetClientByAddr(netAddr dfnet.NetAddr, opts ...grpc.DialOption) (Client, error) { func GetClientByAddr(ctx context.Context, netAddr dfnet.NetAddr, opts ...grpc.DialOption) (Client, error) {
conn, err := grpc.Dial( conn, err := grpc.DialContext(
ctx,
netAddr.Addr, netAddr.Addr,
append([]grpc.DialOption{ append([]grpc.DialOption{
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
@ -87,12 +88,13 @@ func GetClientByAddr(netAddr dfnet.NetAddr, opts ...grpc.DialOption) (Client, er
}, nil }, nil
} }
func GetClient(dynconfig config.DynconfigInterface, opts ...grpc.DialOption) (Client, error) { func GetClient(ctx context.Context, dynconfig config.DynconfigInterface, opts ...grpc.DialOption) (Client, error) {
// Register resolver and balancer. // Register resolver and balancer.
resolver.RegisterSeedPeer(dynconfig) resolver.RegisterSeedPeer(dynconfig)
balancer.Register(pkgbalancer.NewConsistentHashingBuilder()) balancer.Register(pkgbalancer.NewConsistentHashingBuilder())
conn, err := grpc.Dial( conn, err := grpc.DialContext(
ctx,
resolver.SeedPeerVirtualTarget, resolver.SeedPeerVirtualTarget,
append([]grpc.DialOption{ append([]grpc.DialOption{
grpc.WithDefaultServiceConfig(pkgbalancer.BalancerServiceConfig), grpc.WithDefaultServiceConfig(pkgbalancer.BalancerServiceConfig),

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

@ -52,12 +52,13 @@ const (
) )
// GetClient returns dfdaemon client. // GetClient returns dfdaemon client.
func GetClient(target string, opts ...grpc.DialOption) (Client, error) { func GetClient(ctx context.Context, target string, opts ...grpc.DialOption) (Client, error) {
if rpc.IsVsock(target) { if rpc.IsVsock(target) {
opts = append(opts, grpc.WithContextDialer(rpc.VsockDialer)) opts = append(opts, grpc.WithContextDialer(rpc.VsockDialer))
} }
conn, err := grpc.Dial( conn, err := grpc.DialContext(
ctx,
target, target,
append([]grpc.DialOption{ append([]grpc.DialOption{
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),

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

@ -53,8 +53,9 @@ const (
) )
// GetClient returns manager client. // GetClient returns manager client.
func GetClient(target string, opts ...grpc.DialOption) (Client, error) { func GetClient(ctx context.Context, target string, opts ...grpc.DialOption) (Client, error) {
conn, err := grpc.Dial( conn, err := grpc.DialContext(
ctx,
target, target,
append([]grpc.DialOption{ append([]grpc.DialOption{
grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithTransportCredentials(insecure.NewCredentials()),
@ -85,12 +86,12 @@ func GetClient(target string, opts ...grpc.DialOption) (Client, error) {
} }
// GetClientByAddr returns manager client with addresses. // GetClientByAddr returns manager client with addresses.
func GetClientByAddr(netAddrs []dfnet.NetAddr, opts ...grpc.DialOption) (Client, error) { func GetClientByAddr(ctx context.Context, netAddrs []dfnet.NetAddr, opts ...grpc.DialOption) (Client, error) {
for _, netAddr := range netAddrs { for _, netAddr := range netAddrs {
ipReachable := reachable.New(&reachable.Config{Address: netAddr.Addr}) ipReachable := reachable.New(&reachable.Config{Address: netAddr.Addr})
if err := ipReachable.Check(); err == nil { if err := ipReachable.Check(); err == nil {
logger.Infof("use %s address for manager grpc client", netAddr.Addr) logger.Infof("use %s address for manager grpc client", netAddr.Addr)
return GetClient(netAddr.Addr, opts...) return GetClient(ctx, netAddr.Addr, opts...)
} }
logger.Warnf("%s manager address can not reachable", netAddr.Addr) logger.Warnf("%s manager address can not reachable", netAddr.Addr)
} }

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

@ -55,12 +55,13 @@ const (
) )
// GetClient get scheduler clients using resolver and balancer, // GetClient get scheduler clients using resolver and balancer,
func GetClient(dynconfig config.Dynconfig, opts ...grpc.DialOption) (Client, error) { func GetClient(ctx context.Context, dynconfig config.Dynconfig, opts ...grpc.DialOption) (Client, error) {
// Register resolver and balancer. // Register resolver and balancer.
resolver.RegisterScheduler(dynconfig) resolver.RegisterScheduler(dynconfig)
balancer.Register(pkgbalancer.NewConsistentHashingBuilder()) balancer.Register(pkgbalancer.NewConsistentHashingBuilder())
conn, err := grpc.Dial( conn, err := grpc.DialContext(
ctx,
resolver.SchedulerVirtualTarget, resolver.SchedulerVirtualTarget,
append([]grpc.DialOption{ append([]grpc.DialOption{
grpc.WithDefaultServiceConfig(pkgbalancer.BalancerServiceConfig), grpc.WithDefaultServiceConfig(pkgbalancer.BalancerServiceConfig),

3
scheduler/resource/seed_peer_client.go
View File

@ -19,6 +19,7 @@
package resource package resource
import ( import (
"context"
"fmt" "fmt"
reflect "reflect" reflect "reflect"
@ -62,7 +63,7 @@ func newSeedPeerClient(dynconfig config.DynconfigInterface, hostManager HostMana
logger.Infof("initialize seed peer addresses: %#v", seedPeersToNetAddrs(config.SeedPeers)) logger.Infof("initialize seed peer addresses: %#v", seedPeersToNetAddrs(config.SeedPeers))
// Initialize seed peer grpc client. // Initialize seed peer grpc client.
client, err := client.GetClient(dynconfig, opts...) client, err := client.GetClient(context.Background(), dynconfig, opts...)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
scheduler/scheduler.go
View File

@ -77,7 +77,7 @@ func New(ctx context.Context, cfg *config.Config, d dfpath.Dfpath) (*Server, err
s := &Server{config: cfg} s := &Server{config: cfg}
// Initialize manager client. // Initialize manager client.
managerClient, err := managerclient.GetClient(cfg.Manager.Addr) managerClient, err := managerclient.GetClient(ctx, cfg.Manager.Addr)
if err != nil { if err != nil {
return nil, err return nil, err
} }