| /* |
| * |
| * Copyright 2020 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 resolver |
| |
| import ( |
| "encoding/json" |
| "fmt" |
| |
| wrapperspb "github.com/golang/protobuf/ptypes/wrappers" |
| xdsclient "google.golang.org/grpc/xds/internal/client" |
| ) |
| |
| const ( |
| cdsName = "cds_experimental" |
| weightedTargetName = "weighted_target_experimental" |
| xdsRoutingName = "xds_routing_experimental" |
| ) |
| |
| type serviceConfig struct { |
| LoadBalancingConfig balancerConfig `json:"loadBalancingConfig"` |
| } |
| |
| type balancerConfig []map[string]interface{} |
| |
| func newBalancerConfig(name string, config interface{}) balancerConfig { |
| return []map[string]interface{}{{name: config}} |
| } |
| |
| type weightedCDSBalancerConfig struct { |
| Targets map[string]cdsWithWeight `json:"targets"` |
| } |
| |
| type cdsWithWeight struct { |
| Weight uint32 `json:"weight"` |
| ChildPolicy balancerConfig `json:"childPolicy"` |
| } |
| |
| type cdsBalancerConfig struct { |
| Cluster string `json:"cluster"` |
| } |
| |
| type route struct { |
| Path *string `json:"path,omitempty"` |
| Prefix *string `json:"prefix,omitempty"` |
| Regex *string `json:"regex,omitempty"` |
| Headers []*xdsclient.HeaderMatcher `json:"headers,omitempty"` |
| Fraction *wrapperspb.UInt32Value `json:"matchFraction,omitempty"` |
| Action string `json:"action"` |
| } |
| |
| type xdsActionConfig struct { |
| ChildPolicy balancerConfig `json:"childPolicy"` |
| } |
| |
| type xdsRoutingBalancerConfig struct { |
| Action map[string]xdsActionConfig `json:"action"` |
| Route []*route `json:"route"` |
| } |
| |
| func (r *xdsResolver) routesToJSON(routes []*xdsclient.Route) (string, error) { |
| r.updateActions(newActionsFromRoutes(routes)) |
| |
| // Generate routes. |
| var rts []*route |
| for _, rt := range routes { |
| t := &route{ |
| Path: rt.Path, |
| Prefix: rt.Prefix, |
| Regex: rt.Regex, |
| Headers: rt.Headers, |
| } |
| |
| if f := rt.Fraction; f != nil { |
| t.Fraction = &wrapperspb.UInt32Value{Value: *f} |
| } |
| |
| t.Action = r.getActionAssignedName(rt.Action) |
| rts = append(rts, t) |
| } |
| |
| // Generate actions. |
| action := make(map[string]xdsActionConfig) |
| for _, act := range r.actions { |
| action[act.assignedName] = xdsActionConfig{ |
| ChildPolicy: weightedClusterToBalancerConfig(act.clustersWithWeights), |
| } |
| } |
| |
| sc := serviceConfig{ |
| LoadBalancingConfig: newBalancerConfig( |
| xdsRoutingName, xdsRoutingBalancerConfig{ |
| Route: rts, |
| Action: action, |
| }, |
| ), |
| } |
| |
| bs, err := json.Marshal(sc) |
| if err != nil { |
| return "", fmt.Errorf("failed to marshal json: %v", err) |
| } |
| return string(bs), nil |
| } |
| |
| func weightedClusterToBalancerConfig(wc map[string]uint32) balancerConfig { |
| // Even if WeightedCluster has only one entry, we still use weighted_target |
| // as top level balancer, to avoid switching top policy between CDS and |
| // weighted_target, causing TCP connection to be recreated. |
| targets := make(map[string]cdsWithWeight) |
| for name, weight := range wc { |
| targets[name] = cdsWithWeight{ |
| Weight: weight, |
| ChildPolicy: newBalancerConfig(cdsName, cdsBalancerConfig{Cluster: name}), |
| } |
| } |
| bc := newBalancerConfig( |
| weightedTargetName, weightedCDSBalancerConfig{ |
| Targets: targets, |
| }, |
| ) |
| return bc |
| } |
| |
| func (r *xdsResolver) serviceUpdateToJSON(su xdsclient.ServiceUpdate) (string, error) { |
| return r.routesToJSON(su.Routes) |
| } |