mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-10-31 05:40:42 +00:00
234 lines
6.7 KiB
Go
234 lines
6.7 KiB
Go
/*
|
|
*
|
|
* Copyright 2017 gRPC 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.
|
|
*
|
|
*/
|
|
|
|
package grpc
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"google.golang.org/grpc/grpclog"
|
|
)
|
|
|
|
const maxInt = int(^uint(0) >> 1)
|
|
|
|
// MethodConfig defines the configuration recommended by the service providers for a
|
|
// particular method.
|
|
//
|
|
// Deprecated: Users should not use this struct. Service config should be received
|
|
// through name resolver, as specified here
|
|
// https://github.com/grpc/grpc/blob/master/doc/service_config.md
|
|
type MethodConfig struct {
|
|
// WaitForReady indicates whether RPCs sent to this method should wait until
|
|
// the connection is ready by default (!failfast). The value specified via the
|
|
// gRPC client API will override the value set here.
|
|
WaitForReady *bool
|
|
// Timeout is the default timeout for RPCs sent to this method. The actual
|
|
// deadline used will be the minimum of the value specified here and the value
|
|
// set by the application via the gRPC client API. If either one is not set,
|
|
// then the other will be used. If neither is set, then the RPC has no deadline.
|
|
Timeout *time.Duration
|
|
// MaxReqSize is the maximum allowed payload size for an individual request in a
|
|
// stream (client->server) in bytes. The size which is measured is the serialized
|
|
// payload after per-message compression (but before stream compression) in bytes.
|
|
// The actual value used is the minimum of the value specified here and the value set
|
|
// by the application via the gRPC client API. If either one is not set, then the other
|
|
// will be used. If neither is set, then the built-in default is used.
|
|
MaxReqSize *int
|
|
// MaxRespSize is the maximum allowed payload size for an individual response in a
|
|
// stream (server->client) in bytes.
|
|
MaxRespSize *int
|
|
}
|
|
|
|
// ServiceConfig is provided by the service provider and contains parameters for how
|
|
// clients that connect to the service should behave.
|
|
//
|
|
// Deprecated: Users should not use this struct. Service config should be received
|
|
// through name resolver, as specified here
|
|
// https://github.com/grpc/grpc/blob/master/doc/service_config.md
|
|
type ServiceConfig struct {
|
|
// LB is the load balancer the service providers recommends. The balancer specified
|
|
// via grpc.WithBalancer will override this.
|
|
LB *string
|
|
// Methods contains a map for the methods in this service.
|
|
// If there is an exact match for a method (i.e. /service/method) in the map, use the corresponding MethodConfig.
|
|
// If there's no exact match, look for the default config for the service (/service/) and use the corresponding MethodConfig if it exists.
|
|
// Otherwise, the method has no MethodConfig to use.
|
|
Methods map[string]MethodConfig
|
|
|
|
stickinessMetadataKey *string
|
|
}
|
|
|
|
func parseDuration(s *string) (*time.Duration, error) {
|
|
if s == nil {
|
|
return nil, nil
|
|
}
|
|
if !strings.HasSuffix(*s, "s") {
|
|
return nil, fmt.Errorf("malformed duration %q", *s)
|
|
}
|
|
ss := strings.SplitN((*s)[:len(*s)-1], ".", 3)
|
|
if len(ss) > 2 {
|
|
return nil, fmt.Errorf("malformed duration %q", *s)
|
|
}
|
|
// hasDigits is set if either the whole or fractional part of the number is
|
|
// present, since both are optional but one is required.
|
|
hasDigits := false
|
|
var d time.Duration
|
|
if len(ss[0]) > 0 {
|
|
i, err := strconv.ParseInt(ss[0], 10, 32)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
|
|
}
|
|
d = time.Duration(i) * time.Second
|
|
hasDigits = true
|
|
}
|
|
if len(ss) == 2 && len(ss[1]) > 0 {
|
|
if len(ss[1]) > 9 {
|
|
return nil, fmt.Errorf("malformed duration %q", *s)
|
|
}
|
|
f, err := strconv.ParseInt(ss[1], 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("malformed duration %q: %v", *s, err)
|
|
}
|
|
for i := 9; i > len(ss[1]); i-- {
|
|
f *= 10
|
|
}
|
|
d += time.Duration(f)
|
|
hasDigits = true
|
|
}
|
|
if !hasDigits {
|
|
return nil, fmt.Errorf("malformed duration %q", *s)
|
|
}
|
|
|
|
return &d, nil
|
|
}
|
|
|
|
type jsonName struct {
|
|
Service *string
|
|
Method *string
|
|
}
|
|
|
|
func (j jsonName) generatePath() (string, bool) {
|
|
if j.Service == nil {
|
|
return "", false
|
|
}
|
|
res := "/" + *j.Service + "/"
|
|
if j.Method != nil {
|
|
res += *j.Method
|
|
}
|
|
return res, true
|
|
}
|
|
|
|
// TODO(lyuxuan): delete this struct after cleaning up old service config implementation.
|
|
type jsonMC struct {
|
|
Name *[]jsonName
|
|
WaitForReady *bool
|
|
Timeout *string
|
|
MaxRequestMessageBytes *int64
|
|
MaxResponseMessageBytes *int64
|
|
}
|
|
|
|
// TODO(lyuxuan): delete this struct after cleaning up old service config implementation.
|
|
type jsonSC struct {
|
|
LoadBalancingPolicy *string
|
|
StickinessMetadataKey *string
|
|
MethodConfig *[]jsonMC
|
|
}
|
|
|
|
func parseServiceConfig(js string) (ServiceConfig, error) {
|
|
var rsc jsonSC
|
|
err := json.Unmarshal([]byte(js), &rsc)
|
|
if err != nil {
|
|
grpclog.Warningf("grpc: parseServiceConfig error unmarshaling %s due to %v", js, err)
|
|
return ServiceConfig{}, err
|
|
}
|
|
sc := ServiceConfig{
|
|
LB: rsc.LoadBalancingPolicy,
|
|
Methods: make(map[string]MethodConfig),
|
|
|
|
stickinessMetadataKey: rsc.StickinessMetadataKey,
|
|
}
|
|
if rsc.MethodConfig == nil {
|
|
return sc, nil
|
|
}
|
|
|
|
for _, m := range *rsc.MethodConfig {
|
|
if m.Name == nil {
|
|
continue
|
|
}
|
|
d, err := parseDuration(m.Timeout)
|
|
if err != nil {
|
|
grpclog.Warningf("grpc: parseServiceConfig error unmarshaling %s due to %v", js, err)
|
|
return ServiceConfig{}, err
|
|
}
|
|
|
|
mc := MethodConfig{
|
|
WaitForReady: m.WaitForReady,
|
|
Timeout: d,
|
|
}
|
|
if m.MaxRequestMessageBytes != nil {
|
|
if *m.MaxRequestMessageBytes > int64(maxInt) {
|
|
mc.MaxReqSize = newInt(maxInt)
|
|
} else {
|
|
mc.MaxReqSize = newInt(int(*m.MaxRequestMessageBytes))
|
|
}
|
|
}
|
|
if m.MaxResponseMessageBytes != nil {
|
|
if *m.MaxResponseMessageBytes > int64(maxInt) {
|
|
mc.MaxRespSize = newInt(maxInt)
|
|
} else {
|
|
mc.MaxRespSize = newInt(int(*m.MaxResponseMessageBytes))
|
|
}
|
|
}
|
|
for _, n := range *m.Name {
|
|
if path, valid := n.generatePath(); valid {
|
|
sc.Methods[path] = mc
|
|
}
|
|
}
|
|
}
|
|
|
|
return sc, nil
|
|
}
|
|
|
|
func min(a, b *int) *int {
|
|
if *a < *b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func getMaxSize(mcMax, doptMax *int, defaultVal int) *int {
|
|
if mcMax == nil && doptMax == nil {
|
|
return &defaultVal
|
|
}
|
|
if mcMax != nil && doptMax != nil {
|
|
return min(mcMax, doptMax)
|
|
}
|
|
if mcMax != nil {
|
|
return mcMax
|
|
}
|
|
return doptMax
|
|
}
|
|
|
|
func newInt(b int) *int {
|
|
return &b
|
|
}
|