With CoreDNS now supporting etcdv3 as the DNS backend, we can update our federation target to etcdv3. Users will now be able to use etcdv3 server as the federation backbone. Minio will update bucket data to etcdv3 and CoreDNS can pick that data up and serve it as bucket style DNS path.
233 lines
6.7 KiB
Go
233 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
|
|
}
|