Files
archie/internal/infrastructure/staterpc/dial.go
T

96 lines
3.7 KiB
Go

package staterpc
import (
"fmt"
"strings"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/keepalive"
"github.com/samcharles93/archie-core/internal/domain/presence"
"github.com/samcharles93/archie-core/internal/infrastructure/rpctls"
"github.com/samcharles93/archie-core/internal/infrastructure/telemetry"
)
// Dial returns a State Store client for target, attributed to the caller
// service and authenticated by id. The cleanup closes the connection.
func Dial(target, caller string, id *rpctls.Identity, options ...grpc.DialOption) (*Client, func(), error) {
target = strings.TrimSpace(target)
if target == "" {
return nil, nil, fmt.Errorf("state store target is required")
}
creds, err := id.DialOption(target, presence.StateStore)
if err != nil {
return nil, nil, fmt.Errorf("state store: %w", err)
}
return dial(target, creds, caller, "", options)
}
// DialTask returns the client a task container uses: it trusts caPEM and
// presents only the task grant, never a service certificate.
func DialTask(target string, caPEM []byte, grant string) (*Client, func(), error) {
creds, err := rpctls.CAOnlyDialOption(caPEM, target, presence.StateStore)
if err != nil {
return nil, nil, fmt.Errorf("state store: %w", err)
}
return dial(target, creds, presence.Agent, grant, nil)
}
func dial(target string, creds grpc.DialOption, caller, grant string, options []grpc.DialOption) (*Client, func(), error) {
opts := []grpc.DialOption{
creds,
telemetry.ClientOption(),
// Keepalive detects a dead peer on an otherwise silent watch stream.
grpc.WithKeepaliveParams(ClientKeepaliveParams()),
// GetInstalledPackage returns the whole layer, which for an extension is
// a plugin binary well past gRPC's default 4 MiB receive limit.
grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxPackageResponseBytes)),
grpc.WithUnaryInterceptor(UnaryClientCredentialInterceptor(caller, grant)),
grpc.WithStreamInterceptor(StreamClientCredentialInterceptor(caller, grant)),
}
conn, err := grpc.NewClient(target, append(opts, options...)...)
if err != nil {
return nil, nil, fmt.Errorf("create state store client: %w", err)
}
return NewClient(conn), func() { _ = conn.Close() }, nil
}
// maxPackageResponseBytes is the package layer cap plus headroom for the rest
// of the response.
const maxPackageResponseBytes = 80 << 20
// ClientKeepaliveParams are Dial's keepalive settings: ping after 10s idle,
// 5s timeout, no pings without streams.
func ClientKeepaliveParams() keepalive.ClientParameters {
return keepalive.ClientParameters{
Time: 10 * time.Second,
Timeout: 5 * time.Second,
}
}
// serverKeepaliveMinTime is the server half of the same agreement: the
// shortest gap between two pings a State Store server accepts before it counts
// a strike. It is half the client's ping interval rather than a copy of it;
// ServerKeepaliveOption carries the arithmetic.
const serverKeepaliveMinTime = 5 * time.Second
// ServerKeepaliveOption returns the server keepalive enforcement matching
// Dial's clients: pings at least 5s apart are allowed while a stream is open.
func ServerKeepaliveOption() grpc.ServerOption {
return grpc.KeepaliveEnforcementPolicy(ServerKeepalivePolicy())
}
// ServerKeepalivePolicy returns the policy ServerKeepaliveOption installs.
func ServerKeepalivePolicy() keepalive.EnforcementPolicy {
return keepalive.EnforcementPolicy{
MinTime: serverKeepaliveMinTime,
PermitWithoutStream: false,
}
}
// WaitForPeer makes calls to the State Store wait for it to come up
// instead of failing while it is down or restarting. A call that must not
// wait carries its own deadline.
var WaitForPeer = grpc.WithDefaultCallOptions(grpc.WaitForReady(true))