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

Add trafficsplit metrics to CLI (#3176) 

This PR adds `trafficsplit` as a supported resource for the `linkerd stat` command. Users can type `linkerd stat ts` to see the apex and leaf services of their trafficsplits, as well as metrics for those leaf services.
This commit is contained in:
Carol A. Scott 2019-08-14 10:30:57 -07:00 committed by GitHub
parent 9826cbdfe0
commit 00437709eb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 722 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
cli/cmd/stat.go
View File

@ -68,6 +68,7 @@ func newCmdStat() *cobra.Command {
* po mypod1 mypod2
* rc/my-replication-controller
* sts/my-statefulset
* ts/my-split
* authority
* au/my-authority
* all
@ -80,6 +81,7 @@ func newCmdStat() *cobra.Command {
* pods
* replicationcontrollers
* statefulsets
* trafficsplits
* authorities (not supported in --from)
* services (only supported if a --from is also specified, or as a --to)
* all (all resource types, not supported in --from or --to)
@ -113,6 +115,15 @@ If no resource name is specified, displays stats about all resources of the spec
# Get all services in all namespaces that receive calls from hello1 deployment in the test namespace.
linkerd stat services --from deploy/hello1 --from-namespace test --all-namespaces
# Get all trafficsplits and their leaf services.
linkerd stat ts
# Get the hello-split trafficsplit and its leaf services.
linkerd stat ts/hello-split
# Get all trafficsplits and their leaf services, and metrics for any traffic coming to the leaf services from the hello1 deployment.
linkerd stat ts --from deploy/hello1
# Get all namespaces that receive traffic from the default namespace.
linkerd stat namespaces --from ns/default
@ -219,16 +230,30 @@ type row struct {
meshed string
status string
*rowStats
*tsStats
}
type tsStats struct {
apex string
leaf string
weight string
}
var (
nameHeader = "NAME"
namespaceHeader = "NAMESPACE"
apexHeader = "APEX"
leafHeader = "LEAF"
weightHeader = "WEIGHT"
)
func writeStatsToBuffer(rows []*pb.StatTable_PodGroup_Row, w *tabwriter.Writer, options *statOptions) {
maxNameLength := len(nameHeader)
maxNamespaceLength := len(namespaceHeader)
maxApexLength := len(apexHeader)
maxLeafLength := len(leafHeader)
maxWeightLength := len(weightHeader)
statTables := make(map[string]map[string]*row)
prefixTypes := make(map[string]bool)
@ -249,6 +274,9 @@ func writeStatsToBuffer(rows []*pb.StatTable_PodGroup_Row, w *tabwriter.Writer,
namespace := r.Resource.Namespace
key := fmt.Sprintf("%s/%s", namespace, name)
if r.Resource.Type == k8s.TrafficSplit {
key = fmt.Sprintf("%s/%s/%s", namespace, name, r.TsStats.Leaf)
}
resourceKey := r.Resource.Type
if _, ok := statTables[resourceKey]; !ok {
@ -284,6 +312,29 @@ func writeStatsToBuffer(rows []*pb.StatTable_PodGroup_Row, w *tabwriter.Writer,
tcpWriteBytes: getByteRate(r.GetTcpStats().GetWriteBytesTotal(), r.TimeWindow),
}
}
if r.TsStats != nil {
leaf := r.TsStats.Leaf
apex := r.TsStats.Apex
weight := r.TsStats.Weight
if len(leaf) > maxLeafLength {
maxLeafLength = len(leaf)
}
if len(apex) > maxApexLength {
maxApexLength = len(apex)
}
if len(weight) > maxWeightLength {
maxWeightLength = len(weight)
}
statTables[resourceKey][key].tsStats = &tsStats{
apex: apex,
leaf: leaf,
weight: weight,
}
}
}
switch options.outputFormat {
@ -292,13 +343,13 @@ func writeStatsToBuffer(rows []*pb.StatTable_PodGroup_Row, w *tabwriter.Writer,
fmt.Fprintln(os.Stderr, "No traffic found.")
os.Exit(0)
}
printStatTables(statTables, w, maxNameLength, maxNamespaceLength, options)
printStatTables(statTables, w, maxNameLength, maxNamespaceLength, maxLeafLength, maxApexLength, maxWeightLength, options)
case jsonOutput:
printStatJSON(statTables, w)
}
}
func printStatTables(statTables map[string]map[string]*row, w *tabwriter.Writer, maxNameLength int, maxNamespaceLength int, options *statOptions) {
func printStatTables(statTables map[string]map[string]*row, w *tabwriter.Writer, maxNameLength, maxNamespaceLength, maxLeafLength, maxApexLength, maxWeightLength int, options *statOptions) {
usePrefix := false
if len(statTables) > 1 {
usePrefix = true
@ -315,7 +366,7 @@ func printStatTables(statTables map[string]map[string]*row, w *tabwriter.Writer,
if !usePrefix {
resourceTypeLabel = ""
}
printSingleStatTable(stats, resourceTypeLabel, resourceType, w, maxNameLength, maxNamespaceLength, options)
printSingleStatTable(stats, resourceTypeLabel, resourceType, w, maxNameLength, maxNamespaceLength, maxLeafLength, maxApexLength, maxWeightLength, options)
}
}
}
@ -326,32 +377,50 @@ func showTCPBytes(options *statOptions, resourceType string) bool {
}
func showTCPConns(resourceType string) bool {
return resourceType != k8s.Authority
return resourceType != k8s.Authority && resourceType != k8s.TrafficSplit
}
func printSingleStatTable(stats map[string]*row, resourceTypeLabel, resourceType string, w *tabwriter.Writer, maxNameLength int, maxNamespaceLength int, options *statOptions) {
func printSingleStatTable(stats map[string]*row, resourceTypeLabel, resourceType string, w *tabwriter.Writer, maxNameLength, maxNamespaceLength, maxLeafLength, maxApexLength, maxWeightLength int, options *statOptions) {
headers := make([]string, 0)
nameTemplate := fmt.Sprintf("%%-%ds", maxNameLength)
namespaceTemplate := fmt.Sprintf("%%-%ds", maxNamespaceLength)
apexTemplate := fmt.Sprintf("%%-%ds", maxApexLength)
leafTemplate := fmt.Sprintf("%%-%ds", maxLeafLength)
weightTemplate := fmt.Sprintf("%%-%ds", maxWeightLength)
if options.allNamespaces {
headers = append(headers,
namespaceHeader+strings.Repeat(" ", maxNamespaceLength-len(namespaceHeader)))
fmt.Sprintf(namespaceTemplate, namespaceHeader))
}
headers = append(headers, nameHeader+strings.Repeat(" ", maxNameLength-len(nameHeader)))
headers = append(headers,
fmt.Sprintf(nameTemplate, nameHeader))
if resourceType == k8s.Pod {
headers = append(headers, "STATUS")
}
if resourceType == k8s.TrafficSplit {
headers = append(headers,
fmt.Sprintf(apexTemplate, apexHeader),
fmt.Sprintf(leafTemplate, leafHeader),
fmt.Sprintf(weightTemplate, weightHeader))
} else {
headers = append(headers, "MESHED")
}
headers = append(headers, []string{
"MESHED",
"SUCCESS",
"RPS",
"LATENCY_P50",
"LATENCY_P95",
"LATENCY_P99",
"TCP_CONN",
}...)
if resourceType != k8s.TrafficSplit {
headers = append(headers, "TCP_CONN")
}
if showTCPBytes(options, resourceType) {
headers = append(headers, []string{
"READ_BYTES/SEC",
@ -374,9 +443,16 @@ func printSingleStatTable(stats map[string]*row, resourceTypeLabel, resourceType
templateStringEmpty = "%s\t" + templateStringEmpty
}
if resourceType == k8s.TrafficSplit {
templateString = "%s\t%s\t%s\t%s\t%.2f%%\t%.1frps\t%dms\t%dms\t%dms\t"
templateStringEmpty = "%s\t%s\t%s\t%s\t-\t-\t-\t-\t-\t"
}
if !showTCPConns(resourceType) {
if resourceType == k8s.Authority {
// always show TCP Connections as - for Authorities
templateString = templateString + "-\t"
}
} else {
templateString = templateString + "%d\t"
}
@ -401,14 +477,34 @@ func printSingleStatTable(stats map[string]*row, resourceTypeLabel, resourceType
padding = maxNameLength - len(name)
}
apexPadding := 0
leafPadding := 0
if stats[key].tsStats != nil {
if maxApexLength > len(stats[key].tsStats.apex) {
apexPadding = maxApexLength - len(stats[key].tsStats.apex)
}
if maxLeafLength > len(stats[key].tsStats.leaf) {
leafPadding = maxLeafLength - len(stats[key].tsStats.leaf)
}
}
values = append(values, name+strings.Repeat(" ", padding))
if resourceType == k8s.Pod {
values = append(values, stats[key].status)
}
if resourceType == k8s.TrafficSplit {
values = append(values,
stats[key].tsStats.apex+strings.Repeat(" ", apexPadding),
stats[key].tsStats.leaf+strings.Repeat(" ", leafPadding),
stats[key].tsStats.weight,
)
} else {
values = append(values, []interface{}{
stats[key].meshed,
}...)
}
if stats[key].rowStats != nil {
values = append(values, []interface{}{
@ -450,15 +546,18 @@ type jsonStats struct {
Namespace string `json:"namespace"`
Kind string `json:"kind"`
Name string `json:"name"`
Meshed string `json:"meshed"`
Meshed string `json:"meshed,omitempty"`
Success *float64 `json:"success"`
Rps *float64 `json:"rps"`
LatencyMSp50 *uint64 `json:"latency_ms_p50"`
LatencyMSp95 *uint64 `json:"latency_ms_p95"`
LatencyMSp99 *uint64 `json:"latency_ms_p99"`
TCPConnections *uint64 `json:"tcp_open_connections"`
TCPReadBytes *float64 `json:"tcp_read_bytes_rate"`
TCPWriteBytes *float64 `json:"tcp_write_bytes_rate"`
TCPConnections *uint64 `json:"tcp_open_connections,omitempty"`
TCPReadBytes *float64 `json:"tcp_read_bytes_rate,omitempty"`
TCPWriteBytes *float64 `json:"tcp_write_bytes_rate,omitempty"`
Apex string `json:"apex,omitempty"`
Leaf string `json:"leaf,omitempty"`
Weight string `json:"weight,omitempty"`
}
func printStatJSON(statTables map[string]map[string]*row, w *tabwriter.Writer) {
@ -473,7 +572,9 @@ func printStatJSON(statTables map[string]map[string]*row, w *tabwriter.Writer) {
Namespace: namespace,
Kind: resourceType,
Name: name,
Meshed: stats[key].meshed,
}
if resourceType != k8s.TrafficSplit {
entry.Meshed = stats[key].meshed
}
if stats[key].rowStats != nil {
entry.Success = &stats[key].successRate
@ -489,6 +590,11 @@ func printStatJSON(statTables map[string]map[string]*row, w *tabwriter.Writer) {
}
}
if stats[key].tsStats != nil {
entry.Apex = stats[key].apex
entry.Leaf = stats[key].leaf
entry.Weight = stats[key].weight
}
entries = append(entries, entry)
}
}

22
cli/cmd/stat_test.go
View File

@ -43,6 +43,14 @@ func TestStat(t *testing.T) {
}, k8s.Pod, t)
})
t.Run("Returns trafficsplit stats", func(t *testing.T) {
testStatCall(paramsExp{
options: options,
resNs: []string{"default"},
file: "stat_one_ts_output.golden",
}, k8s.TrafficSplit, t)
})
options.outputFormat = jsonOutput
t.Run("Returns namespace stats (json)", func(t *testing.T) {
testStatCall(paramsExp{
@ -57,6 +65,14 @@ func TestStat(t *testing.T) {
}, k8s.Namespace, t)
})
t.Run("Returns trafficsplit stats (json)", func(t *testing.T) {
testStatCall(paramsExp{
options: options,
resNs: []string{"default"},
file: "stat_one_ts_output_json.golden",
}, k8s.TrafficSplit, t)
})
options = newStatOptions()
options.allNamespaces = true
t.Run("Returns all namespace stats", func(t *testing.T) {
@ -167,10 +183,16 @@ func TestStat(t *testing.T) {
func testStatCall(exp paramsExp, resourceType string, t *testing.T) {
mockClient := &public.MockAPIClient{}
response := public.GenStatSummaryResponse("emoji", resourceType, exp.resNs, exp.counts, true, true)
if resourceType == k8s.TrafficSplit {
response = public.GenStatTsResponse("foo-split", resourceType, exp.resNs, true, true)
}
mockClient.StatSummaryResponseToReturn = &response
args := []string{"ns"}
if resourceType == k8s.TrafficSplit {
args = []string{"trafficsplit"}
}
reqs, err := buildStatSummaryRequests(args, exp.options)
if err != nil {
t.Fatalf("Unexpected error: %v", err)

3
cli/cmd/testdata/stat_one_ts_output.golden vendored Normal file
View File

@ -0,0 +1,3 @@
NAME APEX LEAF WEIGHT SUCCESS RPS LATENCY_P50 LATENCY_P95 LATENCY_P99
foo-split apex_name service-1 900m 100.00% 2.0rps 123ms 123ms 123ms
foo-split apex_name service-2 100m 100.00% 2.0rps 123ms 123ms 123ms

28
cli/cmd/testdata/stat_one_ts_output_json.golden vendored Normal file
View File

@ -0,0 +1,28 @@
[
{
"namespace": "default",
"kind": "trafficsplit",
"name": "foo-split",
"success": 1,
"rps": 2.05,
"latency_ms_p50": 123,
"latency_ms_p95": 123,
"latency_ms_p99": 123,
"apex": "apex_name",
"leaf": "service-1",
"weight": "900m"
},
{
"namespace": "default",
"kind": "trafficsplit",
"name": "foo-split",
"success": 1,
"rps": 2.05,
"latency_ms_p50": 123,
"latency_ms_p95": 123,
"latency_ms_p99": 123,
"apex": "apex_name",
"leaf": "service-2",
"weight": "100m"
}
]

13
controller/api/public/prometheus.go
View File

@ -132,6 +132,19 @@ func generateLabelStringWithExclusion(l model.LabelSet, labelName string) string
return fmt.Sprintf("{%s}", strings.Join(lstrs, ", "))
}
// insert a regex-match check into a LabelSet for labels that match the provided
// string. this is modeled on generateLabelStringWithExclusion().
func generateLabelStringWithRegex(l model.LabelSet, labelName string, stringToMatch string) string {
lstrs := make([]string, 0, len(l))
for l, v := range l {
lstrs = append(lstrs, fmt.Sprintf("%s=%q", l, v))
}
lstrs = append(lstrs, fmt.Sprintf(`%s=~"^%s.+"`, labelName, stringToMatch))
sort.Strings(lstrs)
return fmt.Sprintf("{%s}", strings.Join(lstrs, ", "))
}
// determine if we should add "namespace=<namespace>" to a named query
func shouldAddNamespaceLabel(resource *pb.Resource) bool {
return resource.Type != k8s.Namespace && resource.Namespace != ""

173
controller/api/public/stat_summary.go
View File

@ -2,8 +2,10 @@ package public
import (
"context"
"fmt"
"reflect"
"github.com/deislabs/smi-sdk-go/pkg/apis/split/v1alpha1"
proto "github.com/golang/protobuf/proto"
"github.com/linkerd/linkerd2/controller/api/util"
pb "github.com/linkerd/linkerd2/controller/gen/public"
@ -12,6 +14,7 @@ import (
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
@ -31,6 +34,15 @@ type rKey struct {
Name string
}
type tsKey struct {
Namespace string
Type string
Name string
Apex string
Leaf string
Weight string
}
const (
success = "success"
failure = "failure"
@ -50,6 +62,12 @@ type podStats struct {
errors map[string]*pb.PodErrors
}
type trafficSplitStats struct {
namespace string
name string
apex string
}
func (s *grpcServer) StatSummary(ctx context.Context, req *pb.StatSummaryRequest) (*pb.StatSummaryResponse, error) {
// check for well-formed request
@ -92,6 +110,8 @@ func (s *grpcServer) StatSummary(ctx context.Context, req *pb.StatSummaryRequest
go func() {
if isNonK8sResourceQuery(statReq.GetSelector().GetResource().GetType()) {
resultChan <- s.nonK8sResourceQuery(ctx, statReq)
} else if isTrafficSplitQuery(statReq.GetSelector().GetResource().GetType()) {
resultChan <- s.trafficSplitResourceQuery(ctx, statReq)
} else {
resultChan <- s.k8sResourceQuery(ctx, statReq)
}
@ -237,6 +257,92 @@ func (s *grpcServer) k8sResourceQuery(ctx context.Context, req *pb.StatSummaryRe
return resourceResult{res: &rsp, err: nil}
}
func (s *grpcServer) getTrafficSplits(res *pb.Resource) ([]*v1alpha1.TrafficSplit, error) {
var err error
var trafficSplits []*v1alpha1.TrafficSplit
if res.GetNamespace() == "" {
trafficSplits, err = s.k8sAPI.TS().Lister().List(labels.Everything())
} else if res.GetName() == "" {
trafficSplits, err = s.k8sAPI.TS().Lister().TrafficSplits(res.GetNamespace()).List(labels.Everything())
} else {
var ts *v1alpha1.TrafficSplit
ts, err = s.k8sAPI.TS().Lister().TrafficSplits(res.GetNamespace()).Get(res.GetName())
trafficSplits = []*v1alpha1.TrafficSplit{ts}
}
return trafficSplits, err
}
func (s *grpcServer) trafficSplitResourceQuery(ctx context.Context, req *pb.StatSummaryRequest) resourceResult {
tss, err := s.getTrafficSplits(req.GetSelector().GetResource())
if err != nil {
return resourceResult{res: nil, err: err}
}
tsBasicStats := make(map[tsKey]*pb.BasicStats)
rows := make([]*pb.StatTable_PodGroup_Row, 0)
for _, ts := range tss {
backends := ts.Spec.Backends
tsStats := &trafficSplitStats{
namespace: ts.ObjectMeta.Namespace,
name: ts.ObjectMeta.Name,
apex: ts.Spec.Service,
}
if !req.SkipStats {
tsBasicStats, err = s.getTrafficSplitMetrics(ctx, req, tsStats, req.TimeWindow)
if err != nil {
return resourceResult{res: nil, err: err}
}
}
for _, backend := range backends {
name := backend.Service
weight := backend.Weight.String()
currentLeaf := tsKey{
Namespace: tsStats.namespace,
Type: k8s.TrafficSplit,
Name: tsStats.name,
Apex: tsStats.apex,
Leaf: name,
}
trafficSplitStats := &pb.TrafficSplitStats{
Apex: tsStats.apex,
Leaf: name,
Weight: weight,
}
row := pb.StatTable_PodGroup_Row{
Resource: &pb.Resource{
Name: tsStats.name,
Namespace: tsStats.namespace,
Type: req.GetSelector().GetResource().GetType(),
},
TimeWindow: req.TimeWindow,
Stats: tsBasicStats[currentLeaf],
TsStats: trafficSplitStats,
}
rows = append(rows, &row)
}
}
rsp := pb.StatTable{
Table: &pb.StatTable_PodGroup_{
PodGroup: &pb.StatTable_PodGroup{
Rows: rows,
},
},
}
return resourceResult{res: &rsp, err: nil}
}
func (s *grpcServer) nonK8sResourceQuery(ctx context.Context, req *pb.StatSummaryRequest) resourceResult {
var requestMetrics map[rKey]*pb.BasicStats
if !req.SkipStats {
@ -277,6 +383,10 @@ func isNonK8sResourceQuery(resourceType string) bool {
return resourceType == k8s.Authority
}
func isTrafficSplitQuery(resourceType string) bool {
return resourceType == k8s.TrafficSplit
}
// get the list of objects for which we want to return results
func getResultKeys(
req *pb.StatSummaryRequest,
@ -329,6 +439,34 @@ func buildRequestLabels(req *pb.StatSummaryRequest) (labels model.LabelSet, labe
return
}
func buildTrafficSplitRequestLabels(req *pb.StatSummaryRequest) (labels model.LabelSet, labelNames model.LabelNames) {
// trafficsplit labels are always direction="outbound" with an optional namespace="value" if the -A flag is not used.
// if the --from or --to flags were used, we merge an additional ToResource or FromResource label.
// trafficsplit metrics results are always grouped by dst_service.
labels = model.LabelSet{
"direction": model.LabelValue("outbound"),
}
if req.Selector.Resource.Namespace != "" {
labels["namespace"] = model.LabelValue(req.Selector.Resource.Namespace)
}
switch out := req.Outbound.(type) {
case *pb.StatSummaryRequest_ToResource:
labels = labels.Merge(promDstQueryLabels(out.ToResource))
case *pb.StatSummaryRequest_FromResource:
labels = labels.Merge(promQueryLabels(out.FromResource))
default:
// no extra labels needed
}
groupBy := model.LabelNames{model.LabelName("dst_service")}
return labels, groupBy
}
func (s *grpcServer) getStatMetrics(ctx context.Context, req *pb.StatSummaryRequest, timeWindow string) (map[rKey]*pb.BasicStats, map[rKey]*pb.TcpStats, error) {
reqLabels, groupBy := buildRequestLabels(req)
promQueries := map[promType]string{
@ -350,6 +488,41 @@ func (s *grpcServer) getStatMetrics(ctx context.Context, req *pb.StatSummaryRequ
return basicStats, tcpStats, nil
}
func (s *grpcServer) getTrafficSplitMetrics(ctx context.Context, req *pb.StatSummaryRequest, tsStats *trafficSplitStats, timeWindow string) (map[tsKey]*pb.BasicStats, error) {
tsBasicStats := make(map[tsKey]*pb.BasicStats)
labels, groupBy := buildTrafficSplitRequestLabels(req)
apex := tsStats.apex
namespace := tsStats.namespace
// TODO: add cluster domain to stringToMatch
stringToMatch := fmt.Sprintf("%s.%s.svc", apex, namespace)
reqLabels := generateLabelStringWithRegex(labels, "authority", stringToMatch)
promQueries := map[promType]string{
promRequests: reqQuery,
}
results, err := s.getPrometheusMetrics(ctx, promQueries, latencyQuantileQuery, reqLabels, timeWindow, groupBy.String())
if err != nil {
return nil, err
}
basicStats, _ := processPrometheusMetrics(req, results, groupBy) // we don't need tcpStat info for traffic split
for rKey, basicStatsVal := range basicStats {
tsBasicStats[tsKey{
Namespace: namespace,
Name: tsStats.name,
Type: req.Selector.Resource.Type,
Apex: apex,
Leaf: rKey.Name,
}] = basicStatsVal
}
return tsBasicStats, nil
}
func processPrometheusMetrics(req *pb.StatSummaryRequest, results []promResult, groupBy model.LabelNames) (map[rKey]*pb.BasicStats, map[rKey]*pb.TcpStats) {
basicStats := make(map[rKey]*pb.BasicStats)
tcpStats := make(map[rKey]*pb.TcpStats)

7
controller/api/public/stat_summary_test.go
View File

@ -1152,6 +1152,13 @@ status:
},
},
},
{
Table: &pb.StatTable_PodGroup_{
PodGroup: &pb.StatTable_PodGroup{
Rows: []*pb.StatTable_PodGroup_Row{},
},
},
},
{
Table: &pb.StatTable_PodGroup_{
PodGroup: &pb.StatTable_PodGroup{

61
controller/api/public/test_helper.go
View File

@ -331,6 +331,67 @@ func GenStatSummaryResponse(resName, resType string, resNs []string, counts *Pod
return resp
}
// GenStatTsResponse generates a mock Public API StatSummaryResponse
// object in response to a request for trafficsplit stats.
func GenStatTsResponse(resName, resType string, resNs []string, basicStats bool, tsStats bool) pb.StatSummaryResponse {
leaves := map[string]string{
"service-1": "900m",
"service-2": "100m",
}
apex := "apex_name"
rows := []*pb.StatTable_PodGroup_Row{}
for _, ns := range resNs {
for name, weight := range leaves {
statTableRow := &pb.StatTable_PodGroup_Row{
Resource: &pb.Resource{
Namespace: ns,
Type: resType,
Name: resName,
},
TimeWindow: "1m",
}
if basicStats {
statTableRow.Stats = &pb.BasicStats{
SuccessCount: 123,
FailureCount: 0,
LatencyMsP50: 123,
LatencyMsP95: 123,
LatencyMsP99: 123,
}
}
if tsStats {
statTableRow.TsStats = &pb.TrafficSplitStats{
Apex: apex,
Leaf: name,
Weight: weight,
}
}
rows = append(rows, statTableRow)
}
}
resp := pb.StatSummaryResponse{
Response: &pb.StatSummaryResponse_Ok_{ // https://github.com/golang/protobuf/issues/205
Ok: &pb.StatSummaryResponse_Ok{
StatTables: []*pb.StatTable{
{
Table: &pb.StatTable_PodGroup_{
PodGroup: &pb.StatTable_PodGroup{
Rows: rows,
},
},
},
},
},
},
}
return resp
}
// GenEdgesResponse generates a mock Public API StatSummaryResponse
// object.
func GenEdgesResponse(resourceType string, resSrc, resDst, resSrcNamespace, resDstNamespace, resClient, resServer, msg []string) pb.EdgesResponse {

480
controller/gen/public/public.pb.go generated
View File

@ -2846,6 +2846,61 @@ func (m *TcpStats) GetWriteBytesTotal() uint64 {
return 0
}
type TrafficSplitStats struct {
Apex string `protobuf:"bytes,2,opt,name=apex,proto3" json:"apex,omitempty"`
Leaf string `protobuf:"bytes,3,opt,name=leaf,proto3" json:"leaf,omitempty"`
Weight string `protobuf:"bytes,4,opt,name=weight,proto3" json:"weight,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TrafficSplitStats) Reset() { *m = TrafficSplitStats{} }
func (m *TrafficSplitStats) String() string { return proto.CompactTextString(m) }
func (*TrafficSplitStats) ProtoMessage() {}
func (*TrafficSplitStats) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{26}
}
func (m *TrafficSplitStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TrafficSplitStats.Unmarshal(m, b)
}
func (m *TrafficSplitStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TrafficSplitStats.Marshal(b, m, deterministic)
}
func (m *TrafficSplitStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_TrafficSplitStats.Merge(m, src)
}
func (m *TrafficSplitStats) XXX_Size() int {
return xxx_messageInfo_TrafficSplitStats.Size(m)
}
func (m *TrafficSplitStats) XXX_DiscardUnknown() {
xxx_messageInfo_TrafficSplitStats.DiscardUnknown(m)
}
var xxx_messageInfo_TrafficSplitStats proto.InternalMessageInfo
func (m *TrafficSplitStats) GetApex() string {
if m != nil {
return m.Apex
}
return ""
}
func (m *TrafficSplitStats) GetLeaf() string {
if m != nil {
return m.Leaf
}
return ""
}
func (m *TrafficSplitStats) GetWeight() string {
if m != nil {
return m.Weight
}
return ""
}
type StatTable struct {
// Types that are valid to be assigned to Table:
// *StatTable_PodGroup_
@ -2859,7 +2914,7 @@ func (m *StatTable) Reset() { *m = StatTable{} }
func (m *StatTable) String() string { return proto.CompactTextString(m) }
func (*StatTable) ProtoMessage() {}
func (*StatTable) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{26}
return fileDescriptor_413a91106d7bcce8, []int{27}
}
func (m *StatTable) XXX_Unmarshal(b []byte) error {
@ -2922,7 +2977,7 @@ func (m *StatTable_PodGroup) Reset() { *m = StatTable_PodGroup{} }
func (m *StatTable_PodGroup) String() string { return proto.CompactTextString(m) }
func (*StatTable_PodGroup) ProtoMessage() {}
func (*StatTable_PodGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{26, 0}
return fileDescriptor_413a91106d7bcce8, []int{27, 0}
}
func (m *StatTable_PodGroup) XXX_Unmarshal(b []byte) error {
@ -2963,6 +3018,7 @@ type StatTable_PodGroup_Row struct {
FailedPodCount uint64 `protobuf:"varint,6,opt,name=failed_pod_count,json=failedPodCount,proto3" json:"failed_pod_count,omitempty"`
Stats *BasicStats `protobuf:"bytes,5,opt,name=stats,proto3" json:"stats,omitempty"`
TcpStats *TcpStats `protobuf:"bytes,8,opt,name=tcp_stats,json=tcpStats,proto3" json:"tcp_stats,omitempty"`
TsStats *TrafficSplitStats `protobuf:"bytes,10,opt,name=ts_stats,json=tsStats,proto3" json:"ts_stats,omitempty"`
// Stores a set of errors for each pod name. If a pod has no errors, it may be omitted.
ErrorsByPod map[string]*PodErrors `protobuf:"bytes,7,rep,name=errors_by_pod,json=errorsByPod,proto3" json:"errors_by_pod,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -2974,7 +3030,7 @@ func (m *StatTable_PodGroup_Row) Reset() { *m = StatTable_PodGroup_Row{}
func (m *StatTable_PodGroup_Row) String() string { return proto.CompactTextString(m) }
func (*StatTable_PodGroup_Row) ProtoMessage() {}
func (*StatTable_PodGroup_Row) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{26, 0, 0}
return fileDescriptor_413a91106d7bcce8, []int{27, 0, 0}
}
func (m *StatTable_PodGroup_Row) XXX_Unmarshal(b []byte) error {
@ -3051,6 +3107,13 @@ func (m *StatTable_PodGroup_Row) GetTcpStats() *TcpStats {
return nil
}
func (m *StatTable_PodGroup_Row) GetTsStats() *TrafficSplitStats {
if m != nil {
return m.TsStats
}
return nil
}
func (m *StatTable_PodGroup_Row) GetErrorsByPod() map[string]*PodErrors {
if m != nil {
return m.ErrorsByPod
@ -3069,7 +3132,7 @@ func (m *EdgesRequest) Reset() { *m = EdgesRequest{} }
func (m *EdgesRequest) String() string { return proto.CompactTextString(m) }
func (*EdgesRequest) ProtoMessage() {}
func (*EdgesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{27}
return fileDescriptor_413a91106d7bcce8, []int{28}
}
func (m *EdgesRequest) XXX_Unmarshal(b []byte) error {
@ -3111,7 +3174,7 @@ func (m *EdgesResponse) Reset() { *m = EdgesResponse{} }
func (m *EdgesResponse) String() string { return proto.CompactTextString(m) }
func (*EdgesResponse) ProtoMessage() {}
func (*EdgesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{28}
return fileDescriptor_413a91106d7bcce8, []int{29}
}
func (m *EdgesResponse) XXX_Unmarshal(b []byte) error {
@ -3188,7 +3251,7 @@ func (m *EdgesResponse_Ok) Reset() { *m = EdgesResponse_Ok{} }
func (m *EdgesResponse_Ok) String() string { return proto.CompactTextString(m) }
func (*EdgesResponse_Ok) ProtoMessage() {}
func (*EdgesResponse_Ok) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{28, 0}
return fileDescriptor_413a91106d7bcce8, []int{29, 0}
}
func (m *EdgesResponse_Ok) XXX_Unmarshal(b []byte) error {
@ -3231,7 +3294,7 @@ func (m *Edge) Reset() { *m = Edge{} }
func (m *Edge) String() string { return proto.CompactTextString(m) }
func (*Edge) ProtoMessage() {}
func (*Edge) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{29}
return fileDescriptor_413a91106d7bcce8, []int{30}
}
func (m *Edge) XXX_Unmarshal(b []byte) error {
@ -3303,7 +3366,7 @@ func (m *TopRoutesRequest) Reset() { *m = TopRoutesRequest{} }
func (m *TopRoutesRequest) String() string { return proto.CompactTextString(m) }
func (*TopRoutesRequest) ProtoMessage() {}
func (*TopRoutesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{30}
return fileDescriptor_413a91106d7bcce8, []int{31}
}
func (m *TopRoutesRequest) XXX_Unmarshal(b []byte) error {
@ -3397,7 +3460,7 @@ func (m *TopRoutesResponse) Reset() { *m = TopRoutesResponse{} }
func (m *TopRoutesResponse) String() string { return proto.CompactTextString(m) }
func (*TopRoutesResponse) ProtoMessage() {}
func (*TopRoutesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{31}
return fileDescriptor_413a91106d7bcce8, []int{32}
}
func (m *TopRoutesResponse) XXX_Unmarshal(b []byte) error {
@ -3474,7 +3537,7 @@ func (m *TopRoutesResponse_Ok) Reset() { *m = TopRoutesResponse_Ok{} }
func (m *TopRoutesResponse_Ok) String() string { return proto.CompactTextString(m) }
func (*TopRoutesResponse_Ok) ProtoMessage() {}
func (*TopRoutesResponse_Ok) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{31, 0}
return fileDescriptor_413a91106d7bcce8, []int{32, 0}
}
func (m *TopRoutesResponse_Ok) XXX_Unmarshal(b []byte) error {
@ -3514,7 +3577,7 @@ func (m *RouteTable) Reset() { *m = RouteTable{} }
func (m *RouteTable) String() string { return proto.CompactTextString(m) }
func (*RouteTable) ProtoMessage() {}
func (*RouteTable) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{32}
return fileDescriptor_413a91106d7bcce8, []int{33}
}
func (m *RouteTable) XXX_Unmarshal(b []byte) error {
@ -3563,7 +3626,7 @@ func (m *RouteTable_Row) Reset() { *m = RouteTable_Row{} }
func (m *RouteTable_Row) String() string { return proto.CompactTextString(m) }
func (*RouteTable_Row) ProtoMessage() {}
func (*RouteTable_Row) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{32, 0}
return fileDescriptor_413a91106d7bcce8, []int{33, 0}
}
func (m *RouteTable_Row) XXX_Unmarshal(b []byte) error {
@ -3657,6 +3720,7 @@ func init() {
proto.RegisterType((*StatSummaryResponse_Ok)(nil), "linkerd2.public.StatSummaryResponse.Ok")
proto.RegisterType((*BasicStats)(nil), "linkerd2.public.BasicStats")
proto.RegisterType((*TcpStats)(nil), "linkerd2.public.TcpStats")
proto.RegisterType((*TrafficSplitStats)(nil), "linkerd2.public.TrafficSplitStats")
proto.RegisterType((*StatTable)(nil), "linkerd2.public.StatTable")
proto.RegisterType((*StatTable_PodGroup)(nil), "linkerd2.public.StatTable.PodGroup")
proto.RegisterType((*StatTable_PodGroup_Row)(nil), "linkerd2.public.StatTable.PodGroup.Row")
@ -3675,200 +3739,204 @@ func init() {
func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) }
var fileDescriptor_413a91106d7bcce8 = []byte{
// 3086 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcb, 0x73, 0x1b, 0xc7,
0xd1, 0xc7, 0xe2, 0x8d, 0x06, 0x40, 0x42, 0x23, 0x5a, 0x1f, 0x0c, 0xdb, 0xb2, 0xb4, 0x7a, 0x98,
0x9f, 0xf4, 0x7d, 0x20, 0x45, 0x5a, 0xb2, 0x68, 0x39, 0x0f, 0x82, 0x84, 0x45, 0x24, 0x14, 0x09,
0x2f, 0xa0, 0xb8, 0xca, 0xe5, 0x14, 0x6a, 0x89, 0x1d, 0x82, 0x1b, 0x2e, 0x76, 0x56, 0xbb, 0x03,
0xd2, 0xf8, 0x0f, 0x52, 0x95, 0x4a, 0xe5, 0x94, 0x4b, 0x2e, 0x39, 0x27, 0x95, 0x4b, 0x2e, 0xb9,
0xf8, 0x90, 0xaa, 0x5c, 0x73, 0x4e, 0xe5, 0x96, 0x5c, 0x52, 0xb9, 0xb8, 0x72, 0xcb, 0x29, 0x87,
0x54, 0x6a, 0x5e, 0x8b, 0x5d, 0x02, 0xe0, 0x43, 0xce, 0x21, 0x39, 0x61, 0xba, 0xe7, 0xd7, 0x3d,
0x3d, 0x33, 0x3d, 0xdd, 0x3d, 0x83, 0x85, 0x92, 0x37, 0x3a, 0x70, 0xec, 0x7e, 0xdd, 0xf3, 0x09,
0x25, 0x68, 0xd1, 0xb1, 0xdd, 0x63, 0xec, 0x5b, 0x6b, 0x75, 0xc1, 0xae, 0xdd, 0x1c, 0x10, 0x32,
0x70, 0xf0, 0x0a, 0xef, 0x3e, 0x18, 0x1d, 0xae, 0x58, 0x23, 0xdf, 0xa4, 0x36, 0x71, 0x85, 0x40,
0xad, 0xda, 0x27, 0xc3, 0x21, 0x71, 0x57, 0x8e, 0xb0, 0xe9, 0xd0, 0xa3, 0xfe, 0x11, 0xee, 0x1f,
0xcb, 0x9e, 0xeb, 0x7d, 0xe2, 0x1e, 0xda, 0x83, 0x15, 0xf1, 0x23, 0x98, 0x7a, 0x0e, 0x32, 0xcd,
0xa1, 0x47, 0xc7, 0xfa, 0x2b, 0x28, 0x7e, 0x0f, 0xfb, 0x81, 0x4d, 0xdc, 0x96, 0x7b, 0x48, 0xd0,
0xdb, 0x50, 0x18, 0x10, 0xc9, 0xa8, 0x6a, 0xb7, 0xb4, 0xe5, 0x82, 0x31, 0x61, 0xb0, 0xde, 0x83,
0x91, 0xed, 0x58, 0xdb, 0x26, 0xc5, 0xd5, 0xa4, 0xe8, 0x0d, 0x19, 0xe8, 0x3e, 0x2c, 0xf8, 0xd8,
0xc1, 0x66, 0x80, 0x95, 0x82, 0x14, 0x87, 0x9c, 0xe1, 0xea, 0xeb, 0x70, 0x7d, 0xd7, 0x0e, 0x68,
0x07, 0xfb, 0x27, 0x76, 0x1f, 0x07, 0x06, 0x7e, 0x35, 0xc2, 0x01, 0x65, 0xca, 0x5d, 0x73, 0x88,
0x03, 0xcf, 0xec, 0x63, 0x35, 0x74, 0xc8, 0xd0, 0x77, 0x61, 0x29, 0x2e, 0x14, 0x78, 0xc4, 0x0d,
0x30, 0x7a, 0x1f, 0xf2, 0x81, 0xe4, 0x55, 0xb5, 0x5b, 0xa9, 0xe5, 0xe2, 0x5a, 0xb5, 0x7e, 0x66,
0xed, 0xea, 0x52, 0xc8, 0x08, 0x91, 0xfa, 0x33, 0xc8, 0x49, 0x26, 0x42, 0x90, 0x66, 0xa3, 0xc8,
0x11, 0x79, 0x3b, 0x6e, 0x4a, 0xf2, 0xac, 0x29, 0x01, 0x2c, 0x32, 0x53, 0xda, 0xc4, 0x0a, 0x6d,
0xbf, 0x35, 0x65, 0x7b, 0x23, 0x59, 0xd5, 0x22, 0x42, 0xe8, 0x9b, 0xcc, 0x4e, 0x07, 0xf7, 0x29,
0xf1, 0xb9, 0xc6, 0xe2, 0x9a, 0x3e, 0x65, 0xa7, 0x81, 0x03, 0x32, 0xf2, 0xfb, 0xb8, 0xc3, 0x81,
0x36, 0x71, 0x8d, 0x50, 0x46, 0xff, 0x08, 0x2a, 0x93, 0x41, 0xe5, 0xdc, 0x97, 0x21, 0xed, 0x11,
0x4b, 0xcd, 0x7b, 0x69, 0x4a, 0x5f, 0x9b, 0x58, 0x06, 0x47, 0xe8, 0xff, 0x48, 0x43, 0xaa, 0x4d,
0xac, 0x99, 0x93, 0x5d, 0x82, 0x8c, 0x47, 0xac, 0x56, 0x5b, 0x4e, 0x54, 0x10, 0xe8, 0x16, 0x80,
0x85, 0x3d, 0x87, 0x8c, 0x87, 0xd8, 0xa5, 0x62, 0x23, 0x77, 0x12, 0x46, 0x84, 0x87, 0x6e, 0x43,
0xd1, 0xc7, 0x9e, 0x63, 0xf7, 0xcd, 0x5e, 0x80, 0x69, 0x15, 0x14, 0x44, 0x32, 0x3b, 0x98, 0xa2,
0x0f, 0xe0, 0x86, 0xa4, 0xd8, 0x6c, 0x7a, 0x7d, 0xe2, 0x52, 0x9f, 0x38, 0x0e, 0xf6, 0xab, 0x45,
0x89, 0x7e, 0x23, 0xd2, 0xbf, 0x15, 0x76, 0xa3, 0x3b, 0x50, 0x0a, 0xa8, 0x49, 0xf1, 0xe1, 0xc8,
0xe1, 0xca, 0x4b, 0x12, 0x5e, 0x54, 0x5c, 0xa6, 0xfd, 0x5d, 0x00, 0xcb, 0xc4, 0x43, 0xe2, 0x72,
0x48, 0x59, 0x42, 0x0a, 0x82, 0xc7, 0x00, 0x08, 0x52, 0x3f, 0x20, 0x07, 0xd5, 0x05, 0xd9, 0xc3,
0x08, 0x74, 0x03, 0xb2, 0x4c, 0xc7, 0x28, 0xa8, 0xa6, 0xf9, 0x74, 0x25, 0xc5, 0x56, 0xc1, 0xb4,
0x2c, 0x6c, 0x55, 0x33, 0xb7, 0xb4, 0xe5, 0xbc, 0x21, 0x08, 0xb4, 0x05, 0x8b, 0x81, 0xed, 0xf6,
0xf1, 0xae, 0x19, 0x50, 0x03, 0x7b, 0xc4, 0xa7, 0xd5, 0x2c, 0xdf, 0xbc, 0x37, 0xeb, 0xe2, 0x3c,
0xd6, 0xd5, 0x79, 0xac, 0x6f, 0xcb, 0xf3, 0x68, 0x9c, 0x95, 0x40, 0xab, 0x70, 0x7d, 0x32, 0xf3,
0xbd, 0xd0, 0x4d, 0x72, 0x7c, 0xfc, 0x59, 0x5d, 0x48, 0x87, 0x92, 0x64, 0xb7, 0x1d, 0xd3, 0xc5,
0xd5, 0x3c, 0xb7, 0x29, 0xc6, 0x43, 0x8f, 0x20, 0x3b, 0xf2, 0xa8, 0x3d, 0xc4, 0xd5, 0xc2, 0x45,
0x16, 0x49, 0x20, 0xba, 0x09, 0xe0, 0xf9, 0xe4, 0x8b, 0xb1, 0x81, 0x4d, 0x6b, 0x5c, 0x5d, 0xe4,
0x4a, 0x23, 0x1c, 0x36, 0x2c, 0xa7, 0xd4, 0xf1, 0xad, 0x70, 0x0b, 0x63, 0x3c, 0xb4, 0x0c, 0x8b,
0xbe, 0x74, 0x53, 0x05, 0xbb, 0xc6, 0x61, 0x67, 0xd9, 0x8d, 0x1c, 0x64, 0xc8, 0xa9, 0x8b, 0x7d,
0xfd, 0x97, 0x49, 0x80, 0xae, 0xe9, 0xa9, 0xb3, 0x82, 0x20, 0xe5, 0x11, 0x4b, 0xb8, 0x20, 0xdb,
0x15, 0x8f, 0x58, 0x67, 0xbc, 0x2d, 0x39, 0xc3, 0xdb, 0x6e, 0x40, 0x76, 0x68, 0x7e, 0x61, 0x78,
0x01, 0xf7, 0xc5, 0xa4, 0x21, 0x29, 0xc6, 0xa7, 0xa4, 0xcd, 0x36, 0x86, 0xed, 0x67, 0xd9, 0x90,
0x14, 0xf3, 0x74, 0x4a, 0x5a, 0x6d, 0xbe, 0x9d, 0x05, 0x83, 0xb7, 0x51, 0x0d, 0xf2, 0x87, 0x3e,
0x19, 0xb6, 0xd5, 0x36, 0x96, 0x8d, 0x90, 0x66, 0x7a, 0x58, 0xbb, 0xd5, 0x96, 0xfb, 0x22, 0x29,
0xee, 0x2f, 0xfd, 0x23, 0x3c, 0x14, 0x9b, 0xc0, 0xfc, 0x85, 0x53, 0xdc, 0x1e, 0x4c, 0x8f, 0x88,
0xc5, 0x97, 0xbf, 0x60, 0x48, 0x8a, 0x85, 0x0e, 0x73, 0x44, 0x8f, 0x88, 0x6f, 0xd3, 0xb1, 0x38,
0x13, 0xc6, 0x84, 0xc1, 0xac, 0xf2, 0x4c, 0x7a, 0x24, 0xdc, 0xdf, 0xe0, 0xed, 0x0f, 0x93, 0x55,
0xad, 0x91, 0x87, 0x2c, 0x35, 0xfd, 0x01, 0xa6, 0xfa, 0x5f, 0x33, 0xb0, 0xd4, 0x35, 0xbd, 0xc6,
0x58, 0x05, 0x03, 0xb5, 0x6c, 0x1f, 0x2a, 0x08, 0x5f, 0xb9, 0xcb, 0x85, 0x0f, 0x29, 0x81, 0x36,
0x21, 0x33, 0x34, 0x69, 0xff, 0x48, 0x46, 0x9e, 0x87, 0x53, 0xa2, 0xb3, 0x46, 0xac, 0xbf, 0x60,
0x22, 0x86, 0x90, 0x9c, 0xb7, 0xfe, 0xb5, 0xdf, 0xa4, 0x21, 0xc3, 0x81, 0x68, 0x0b, 0x52, 0xa6,
0xe3, 0x48, 0xeb, 0x56, 0xae, 0x30, 0x44, 0xbd, 0x83, 0x5f, 0x31, 0x47, 0x30, 0x1d, 0x87, 0x2b,
0x71, 0xc7, 0xd2, 0xce, 0xd7, 0x52, 0xe2, 0x8e, 0xd1, 0xb7, 0x20, 0xe5, 0x12, 0x11, 0xb4, 0xae,
0x36, 0x59, 0xa6, 0xc0, 0x25, 0x14, 0xed, 0x40, 0xc9, 0xc2, 0x01, 0xb5, 0x5d, 0x7e, 0x7e, 0x44,
0xa8, 0xb8, 0xd4, 0x8a, 0xef, 0x24, 0x8c, 0x98, 0x24, 0xfa, 0x18, 0xd2, 0x47, 0x94, 0x7a, 0xdc,
0x0d, 0x8b, 0x6b, 0xab, 0x57, 0x99, 0xd0, 0x0e, 0xa5, 0xde, 0x4e, 0xc2, 0xe0, 0xf2, 0xb5, 0x5d,
0x48, 0x75, 0xf0, 0x2b, 0xd4, 0x84, 0x1c, 0xdf, 0x8e, 0x30, 0xd9, 0x5d, 0x69, 0x2b, 0x95, 0x6c,
0x6d, 0x0c, 0x69, 0xa6, 0x1d, 0x55, 0x43, 0xe7, 0x56, 0xa7, 0x51, 0xb9, 0x77, 0x35, 0x74, 0x6f,
0x75, 0x18, 0x95, 0x83, 0xdf, 0x8c, 0x3a, 0xb8, 0xca, 0x0b, 0x11, 0x17, 0x5f, 0x92, 0x2e, 0x9e,
0x96, 0x5d, 0x9c, 0x62, 0xc1, 0x80, 0x0f, 0x1e, 0x36, 0xf4, 0xbf, 0x6b, 0x00, 0xcc, 0x88, 0x17,
0x42, 0xed, 0x0e, 0x80, 0x8f, 0x07, 0x76, 0x40, 0xb1, 0x8f, 0x45, 0x70, 0x58, 0x58, 0xbb, 0x3f,
0x35, 0xb9, 0x89, 0x40, 0xdd, 0x08, 0xd1, 0x22, 0xe9, 0x28, 0x0a, 0xdd, 0x85, 0xd2, 0xc8, 0x8d,
0xe8, 0x52, 0x13, 0x88, 0x71, 0x75, 0x17, 0x60, 0xa2, 0x01, 0xe5, 0x20, 0xf5, 0xbc, 0xd9, 0xad,
0x24, 0x50, 0x1e, 0xd2, 0xed, 0xfd, 0x4e, 0xb7, 0xa2, 0x31, 0x56, 0xfb, 0x65, 0xb7, 0x92, 0x44,
0x00, 0xd9, 0xed, 0xe6, 0x6e, 0xb3, 0xdb, 0xac, 0xa4, 0x50, 0x01, 0x32, 0xed, 0xcd, 0xee, 0xd6,
0x4e, 0x25, 0x8d, 0x8a, 0x90, 0xdb, 0x6f, 0x77, 0x5b, 0xfb, 0x7b, 0x9d, 0x4a, 0x86, 0x11, 0x5b,
0xfb, 0x7b, 0x7b, 0xcd, 0xad, 0x6e, 0x25, 0xcb, 0x74, 0xec, 0x34, 0x37, 0xb7, 0x2b, 0x39, 0x06,
0xef, 0x1a, 0x9b, 0x5b, 0xcd, 0x4a, 0xbe, 0x91, 0x85, 0x34, 0x1d, 0x7b, 0x58, 0xff, 0xb9, 0x06,
0xd9, 0x8e, 0x58, 0xe3, 0xed, 0x19, 0x53, 0x9e, 0xf6, 0x31, 0x01, 0xfe, 0xba, 0xd3, 0xbd, 0x1d,
0x9b, 0x2e, 0xb3, 0xb0, 0xdb, 0x6d, 0x57, 0x12, 0xcc, 0x42, 0xd6, 0xea, 0x54, 0xb4, 0xd0, 0xc2,
0x2e, 0x14, 0x5a, 0xed, 0x4d, 0xcb, 0xf2, 0x71, 0xc0, 0xd2, 0x62, 0xda, 0xf6, 0x4e, 0xde, 0xe7,
0xd6, 0xe5, 0xd8, 0x6e, 0x32, 0x0a, 0x3d, 0xe4, 0xdc, 0x27, 0xf2, 0x98, 0xbe, 0x31, 0x65, 0x73,
0xab, 0x7d, 0xf2, 0x44, 0x82, 0x9f, 0x34, 0xd2, 0x90, 0xb4, 0x3d, 0x7d, 0x15, 0xd2, 0x8c, 0xcb,
0xf2, 0xec, 0xa1, 0xed, 0x07, 0x22, 0x8a, 0x65, 0x0d, 0x41, 0xb0, 0xb8, 0xe8, 0x98, 0x81, 0x88,
0xfc, 0x59, 0x83, 0xb7, 0xf5, 0x5d, 0x80, 0x6e, 0xdf, 0x53, 0x86, 0x3c, 0x60, 0x5a, 0x64, 0x70,
0xa9, 0xcd, 0x18, 0x50, 0xe2, 0x8c, 0xa4, 0xed, 0xf1, 0x28, 0xcb, 0x62, 0x7c, 0x92, 0xc7, 0x78,
0xde, 0xd6, 0x2d, 0x48, 0x35, 0x09, 0x53, 0x53, 0x19, 0xf8, 0x5e, 0xbf, 0x27, 0xb2, 0x7e, 0xaf,
0x4f, 0x2c, 0xe1, 0xfb, 0xe5, 0x9d, 0x84, 0xb1, 0xc0, 0x7a, 0x3a, 0xbc, 0x63, 0x8b, 0x58, 0x98,
0x61, 0x7d, 0x1c, 0x60, 0xda, 0xc3, 0xbe, 0x4f, 0x7c, 0x81, 0x4d, 0x2a, 0x2c, 0xef, 0x69, 0xb2,
0x0e, 0x86, 0x6d, 0x64, 0x20, 0x85, 0x5d, 0x4b, 0xff, 0xc3, 0x02, 0xe4, 0xbb, 0xa6, 0xd7, 0x3c,
0x61, 0x29, 0x6b, 0x1d, 0xb2, 0xe2, 0x14, 0x4a, 0xb3, 0xdf, 0x9a, 0x3e, 0xab, 0xe1, 0xfc, 0x0c,
0x09, 0x45, 0xcf, 0xa1, 0x28, 0x5a, 0xbd, 0x21, 0xa6, 0xa6, 0x8c, 0x1b, 0xf7, 0x67, 0x9d, 0x72,
0x3e, 0x48, 0xbd, 0xe9, 0x5a, 0x1e, 0xb1, 0x5d, 0xfa, 0x02, 0x53, 0xd3, 0x00, 0x21, 0xca, 0xda,
0xe8, 0x1b, 0x50, 0x8c, 0x44, 0x22, 0xb9, 0x55, 0xe7, 0x9a, 0x10, 0xc5, 0xa3, 0x4f, 0xa0, 0x12,
0x21, 0x85, 0x31, 0xe9, 0x2b, 0x19, 0xb3, 0x18, 0x91, 0xe7, 0x16, 0x35, 0x00, 0x7c, 0x32, 0xa2,
0x72, 0x66, 0x39, 0xae, 0xec, 0xce, 0x7c, 0x65, 0x06, 0xc3, 0x72, 0x4d, 0x05, 0x5f, 0x35, 0xd1,
0x27, 0xb0, 0xc8, 0xcb, 0x91, 0x9e, 0x65, 0xfb, 0x22, 0xe4, 0xf2, 0x4c, 0xbe, 0xb0, 0xb6, 0x3c,
0x5f, 0x51, 0x9b, 0x09, 0x6c, 0x2b, 0xbc, 0xb1, 0xe0, 0xc5, 0x68, 0xf4, 0xbe, 0x0c, 0xd1, 0x22,
0x5d, 0xdc, 0x9c, 0xaf, 0x27, 0x16, 0x90, 0x7f, 0xaa, 0x41, 0x29, 0x3a, 0x5d, 0xf4, 0x1d, 0xc8,
0x3a, 0xe6, 0x01, 0x76, 0x54, 0x64, 0x5e, 0xbb, 0xdc, 0x32, 0xd5, 0x77, 0xb9, 0x50, 0xd3, 0xa5,
0xfe, 0xd8, 0x90, 0x1a, 0x6a, 0x1b, 0x50, 0x8c, 0xb0, 0x51, 0x05, 0x52, 0xc7, 0x78, 0x2c, 0x8b,
0x76, 0xd6, 0x64, 0xa7, 0xe8, 0xc4, 0x74, 0x46, 0xea, 0x72, 0x22, 0x88, 0x0f, 0x93, 0x4f, 0xb5,
0xda, 0x4f, 0x34, 0x28, 0x84, 0x2b, 0x87, 0x9e, 0x9f, 0x31, 0x6a, 0xe5, 0x12, 0xcb, 0xfd, 0xef,
0xb6, 0xe8, 0x9f, 0x39, 0x99, 0x6d, 0xf6, 0xa1, 0xe4, 0x8b, 0x7c, 0xd4, 0xb3, 0x5d, 0x5b, 0xd5,
0x31, 0x0f, 0xce, 0x5f, 0xf0, 0xba, 0x4c, 0x61, 0x2d, 0xd7, 0xa6, 0xec, 0x02, 0xe0, 0x4f, 0x48,
0x64, 0x40, 0xd9, 0x97, 0x77, 0x21, 0xa1, 0xf1, 0x9c, 0xf2, 0x26, 0xa6, 0x51, 0xc8, 0x48, 0x95,
0x25, 0x3f, 0x42, 0x0b, 0x23, 0xa5, 0x4e, 0xec, 0x5a, 0xd2, 0x2b, 0x1e, 0x5c, 0x52, 0x65, 0xd3,
0xb5, 0x84, 0x91, 0x21, 0x59, 0x7b, 0x02, 0xf9, 0x0e, 0xf5, 0xb1, 0x39, 0x6c, 0xf1, 0xeb, 0xd7,
0x81, 0x19, 0xc8, 0x88, 0x63, 0xf0, 0xb6, 0xb8, 0x90, 0xb0, 0x7e, 0x6e, 0x7d, 0xda, 0x90, 0x54,
0xed, 0x4f, 0x1a, 0x14, 0x23, 0x73, 0x47, 0x1f, 0x40, 0xd2, 0xb6, 0xe4, 0x9a, 0xbd, 0x77, 0x81,
0x39, 0x6a, 0x40, 0x23, 0x69, 0x5b, 0x2c, 0x0c, 0x45, 0x52, 0xf9, 0xac, 0x18, 0x30, 0xc9, 0xaa,
0x61, 0x96, 0x5f, 0x09, 0x2b, 0x03, 0xb1, 0x00, 0xff, 0x33, 0x27, 0x2f, 0x85, 0x05, 0x43, 0xac,
0xee, 0x4d, 0xcf, 0xab, 0x7b, 0x33, 0x93, 0xba, 0xb7, 0xf6, 0x6b, 0x0d, 0x4a, 0xd1, 0xad, 0x78,
0xfd, 0x19, 0x3e, 0x07, 0xc4, 0xef, 0x5c, 0xbd, 0x98, 0x7b, 0x25, 0x2f, 0xba, 0x16, 0x55, 0xb8,
0x50, 0x74, 0x8d, 0xdf, 0x85, 0x22, 0x3b, 0xdc, 0x32, 0x3b, 0xf0, 0xa9, 0x97, 0x0d, 0x60, 0x2c,
0x91, 0x16, 0x6a, 0xbf, 0x48, 0xb2, 0x4d, 0x09, 0x37, 0xf7, 0x3f, 0xc0, 0xe4, 0x16, 0x5c, 0x57,
0x8a, 0xa2, 0x27, 0x21, 0x75, 0x91, 0xa6, 0x6b, 0x52, 0x53, 0x64, 0xfd, 0xef, 0xc1, 0x42, 0xa8,
0xe4, 0x60, 0x4c, 0xb1, 0xa8, 0x7b, 0xd3, 0x46, 0x78, 0xc8, 0x1a, 0x8c, 0x89, 0xee, 0x43, 0x0a,
0x93, 0x40, 0x66, 0xa6, 0xe9, 0x47, 0x87, 0x26, 0x09, 0x0c, 0x06, 0x60, 0x95, 0x1e, 0x66, 0xb3,
0xd7, 0x9f, 0xc2, 0x42, 0x3c, 0x04, 0xb3, 0x72, 0xe9, 0xe5, 0xde, 0x77, 0xf7, 0xf6, 0x3f, 0xdd,
0xab, 0x24, 0x18, 0xd1, 0xda, 0x6b, 0xec, 0xbf, 0xdc, 0xdb, 0xae, 0x68, 0xa8, 0x04, 0xf9, 0xfd,
0x97, 0x5d, 0x41, 0x25, 0x27, 0x2a, 0x6e, 0x41, 0x7e, 0xd3, 0xb3, 0x79, 0xba, 0x65, 0x91, 0x86,
0x27, 0x64, 0x19, 0x7d, 0x04, 0xc1, 0x2e, 0x99, 0x85, 0x36, 0xb1, 0x38, 0x24, 0x40, 0xcf, 0x20,
0xcb, 0xd9, 0x2a, 0xee, 0xdd, 0x99, 0xf5, 0x36, 0x22, 0xb0, 0x61, 0xcb, 0x90, 0x22, 0xb5, 0x3f,
0x6b, 0x90, 0x57, 0x4c, 0x64, 0x40, 0x81, 0x5d, 0xbb, 0x4d, 0xdb, 0xc5, 0xbe, 0xdc, 0xe8, 0xb5,
0x4b, 0x28, 0xab, 0x6f, 0x29, 0x21, 0x4e, 0xb2, 0x12, 0x39, 0x54, 0x53, 0x3b, 0x81, 0x85, 0x78,
0x37, 0xaa, 0x42, 0x6e, 0x88, 0x83, 0xc0, 0x1c, 0xa8, 0xa7, 0x19, 0x45, 0xb2, 0x73, 0x35, 0x19,
0x5f, 0x3e, 0x45, 0x85, 0x0c, 0xb6, 0x16, 0xf6, 0x90, 0x49, 0x89, 0x97, 0x36, 0x41, 0xb0, 0x90,
0xe2, 0x63, 0x33, 0x20, 0xae, 0x7a, 0xe3, 0x10, 0x14, 0x5f, 0x4e, 0xbe, 0x58, 0x6d, 0xc8, 0xab,
0x1b, 0xc2, 0xf9, 0xcf, 0x6e, 0xfc, 0x1a, 0x3d, 0xf6, 0x54, 0x54, 0xe7, 0xed, 0xf0, 0x11, 0x29,
0x35, 0x79, 0x44, 0xd2, 0x5f, 0xc1, 0xb5, 0xa9, 0xcb, 0x10, 0x7a, 0x0c, 0x79, 0xf5, 0x28, 0x20,
0x97, 0xee, 0xcd, 0xb9, 0x57, 0x28, 0x23, 0x84, 0x32, 0x3f, 0xe4, 0x59, 0xa7, 0x17, 0x7b, 0x30,
0x2b, 0x18, 0x65, 0xce, 0xed, 0xa8, 0x17, 0xb1, 0xcf, 0xa1, 0xac, 0x84, 0xc5, 0x22, 0xbe, 0xe6,
0x70, 0xa1, 0x3f, 0x25, 0xa3, 0xfe, 0xf4, 0x55, 0x12, 0x10, 0x3b, 0xf4, 0x9d, 0xd1, 0x70, 0x68,
0xfa, 0x63, 0x75, 0x0b, 0x8f, 0x3e, 0xe3, 0x69, 0x57, 0x7f, 0xc6, 0x63, 0x11, 0x86, 0xda, 0x43,
0xdc, 0x3b, 0xb5, 0x5d, 0x8b, 0x9c, 0xca, 0x21, 0x81, 0xb1, 0x3e, 0xe5, 0x1c, 0xf4, 0x7f, 0x90,
0x76, 0x89, 0xab, 0xc2, 0xee, 0x8d, 0xe9, 0xe3, 0x35, 0xf4, 0xe8, 0x98, 0x55, 0x21, 0x0c, 0x85,
0x3e, 0x82, 0x22, 0x25, 0xbd, 0x70, 0xd6, 0xe9, 0x0b, 0x66, 0xcd, 0xae, 0x0e, 0x94, 0x84, 0x5b,
0xff, 0x6d, 0x28, 0x1f, 0xfa, 0x64, 0x38, 0x91, 0xcf, 0x5c, 0x2c, 0x5f, 0x62, 0x12, 0xa1, 0x86,
0x77, 0x00, 0x82, 0x63, 0x5b, 0x04, 0xcc, 0x80, 0x57, 0x62, 0x79, 0xa3, 0xc0, 0x38, 0x6c, 0xe9,
0x02, 0xf4, 0x16, 0x14, 0x68, 0x5f, 0xf5, 0xe6, 0x78, 0x6f, 0x9e, 0xf6, 0x45, 0x67, 0x03, 0x20,
0x4f, 0x46, 0xf4, 0x80, 0x8c, 0x5c, 0x4b, 0xff, 0xa3, 0x06, 0xd7, 0x63, 0xab, 0x2d, 0x5f, 0x38,
0x37, 0x20, 0x49, 0x8e, 0xe7, 0xc6, 0xd7, 0x19, 0x12, 0xf5, 0xfd, 0xe3, 0x9d, 0x84, 0x91, 0x24,
0xc7, 0xe8, 0x49, 0x74, 0x5b, 0x67, 0xd5, 0x75, 0x31, 0xe7, 0xd9, 0x49, 0xc8, 0x8d, 0xaf, 0x6d,
0x42, 0x72, 0xff, 0x18, 0x3d, 0x03, 0xfe, 0xd4, 0xd8, 0xa3, 0xe6, 0x81, 0x13, 0x5e, 0xb6, 0x6b,
0x33, 0x2d, 0xe8, 0x32, 0x88, 0x01, 0x81, 0x6a, 0xf2, 0x99, 0xa9, 0x90, 0xa9, 0xff, 0x2a, 0x09,
0xd0, 0x30, 0x03, 0xbb, 0x2f, 0x56, 0xe4, 0x0e, 0x94, 0x83, 0x51, 0xbf, 0x8f, 0x03, 0x76, 0xf7,
0x18, 0xb9, 0xa2, 0x08, 0x4a, 0x1b, 0x25, 0xc9, 0xdc, 0x62, 0x3c, 0x06, 0x3a, 0x34, 0x6d, 0x67,
0xe4, 0x63, 0x09, 0x12, 0x95, 0x41, 0x49, 0x32, 0x05, 0xe8, 0x2e, 0x3b, 0x25, 0x14, 0xbb, 0xfd,
0x71, 0x6f, 0x18, 0xf4, 0xbc, 0xc7, 0xab, 0xdc, 0x65, 0xd2, 0x46, 0x49, 0x72, 0x5f, 0x04, 0xed,
0xc7, 0xab, 0x67, 0x51, 0x1b, 0x8f, 0x65, 0x4c, 0x8f, 0xa0, 0x36, 0x1e, 0x4f, 0xa1, 0x36, 0xb8,
0x27, 0xc4, 0x51, 0x1b, 0x68, 0x15, 0x96, 0xcc, 0x3e, 0x1d, 0x99, 0x4e, 0x2f, 0x3e, 0x85, 0x2c,
0xc7, 0x22, 0xd1, 0xd7, 0x89, 0x4e, 0x64, 0x22, 0x11, 0x9f, 0x4f, 0x2e, 0x2a, 0xf1, 0x71, 0x64,
0x56, 0xfa, 0x8f, 0x34, 0xc8, 0x77, 0xa5, 0x87, 0xa0, 0xff, 0x85, 0x0a, 0xf1, 0x30, 0x7f, 0x37,
0x76, 0xc5, 0x49, 0x0a, 0xe4, 0x7a, 0x2d, 0x32, 0xfe, 0xd6, 0x84, 0x8d, 0x96, 0xd9, 0x5d, 0xcd,
0xb4, 0x44, 0xde, 0xea, 0x51, 0x42, 0x4d, 0x47, 0xae, 0xda, 0x02, 0xe3, 0xf3, 0xcc, 0xd5, 0x65,
0x5c, 0xf4, 0x00, 0xae, 0x9d, 0xfa, 0x36, 0xc5, 0x31, 0xa8, 0x58, 0xba, 0x45, 0xde, 0x31, 0xc1,
0xea, 0xbf, 0xcd, 0x40, 0x21, 0xdc, 0x62, 0xd4, 0x80, 0x82, 0x47, 0xac, 0xde, 0xc0, 0x27, 0x23,
0x75, 0x13, 0xbd, 0x33, 0xdf, 0x23, 0x58, 0x2a, 0x78, 0xce, 0xa0, 0x3b, 0x09, 0x23, 0xef, 0xc9,
0x76, 0xed, 0x2f, 0x69, 0x9e, 0x5b, 0x38, 0x81, 0x9e, 0x41, 0xda, 0x27, 0xa7, 0xca, 0xbb, 0xde,
0xbb, 0x84, 0xae, 0xba, 0x41, 0x4e, 0x0d, 0x2e, 0x54, 0xfb, 0x59, 0x1a, 0x52, 0x06, 0x39, 0x7d,
0xdd, 0xa8, 0x77, 0x61, 0x20, 0x9a, 0x3c, 0x94, 0x17, 0x62, 0x0f, 0xe5, 0xcb, 0x50, 0x19, 0xe2,
0xe0, 0x08, 0x5b, 0x3d, 0xb6, 0x18, 0x62, 0x3f, 0xc5, 0xf2, 0x2d, 0x08, 0x7e, 0x9b, 0x58, 0x62,
0xf7, 0x1f, 0xc0, 0x35, 0x7f, 0xe4, 0xba, 0xb6, 0x3b, 0x88, 0x40, 0x85, 0xfb, 0x2d, 0xca, 0x8e,
0x10, 0xbb, 0x0c, 0x15, 0xe6, 0x22, 0x31, 0xad, 0xc2, 0xaf, 0x16, 0x04, 0x3f, 0x44, 0x3e, 0x82,
0x8c, 0x88, 0x27, 0x99, 0x39, 0xd5, 0xec, 0xe4, 0xb4, 0x19, 0x02, 0x89, 0x9e, 0x44, 0xc3, 0x50,
0x7e, 0xce, 0x1a, 0x29, 0xaf, 0x9b, 0x44, 0x28, 0xf4, 0x39, 0x94, 0x45, 0x49, 0xd0, 0x3b, 0x18,
0x33, 0xbb, 0xaa, 0x39, 0xbe, 0x51, 0x4f, 0x2f, 0xb9, 0x51, 0x75, 0x51, 0x13, 0x34, 0xc6, 0xac,
0x28, 0xe0, 0xb7, 0xa9, 0x22, 0x9e, 0x70, 0x6a, 0x9f, 0x41, 0xe5, 0x2c, 0x60, 0xc6, 0xbd, 0x6a,
0x35, 0x7a, 0xaf, 0x9a, 0x15, 0x82, 0xc2, 0xda, 0x23, 0x72, 0xe7, 0x62, 0x99, 0x9e, 0x47, 0x2e,
0x7d, 0x0f, 0x4a, 0x4d, 0x6b, 0x30, 0xf9, 0x93, 0xed, 0x6b, 0xe6, 0x2f, 0xfd, 0x4b, 0x0d, 0xca,
0x52, 0xa1, 0x0c, 0xd1, 0xeb, 0x91, 0x10, 0x7d, 0x7b, 0x3a, 0x5d, 0x45, 0xb1, 0x5f, 0x3f, 0x38,
0x3f, 0xe2, 0xc1, 0xf9, 0x21, 0x64, 0x30, 0xd3, 0x2b, 0x0f, 0xce, 0x1b, 0x33, 0x47, 0x35, 0x04,
0x26, 0x16, 0x8c, 0x7f, 0xa7, 0x41, 0x9a, 0xf5, 0xa1, 0x87, 0x90, 0x0a, 0xfc, 0xfe, 0xc5, 0xe7,
0x85, 0xa1, 0x18, 0xd8, 0x0a, 0x26, 0xc5, 0xf9, 0x7c, 0xb0, 0x15, 0x50, 0x96, 0xf2, 0xfa, 0x8e,
0x8d, 0x5d, 0xda, 0xb3, 0x2d, 0x59, 0x21, 0xe5, 0x05, 0xa3, 0x65, 0xb1, 0xce, 0x00, 0xfb, 0x27,
0xd8, 0x67, 0x9d, 0xa2, 0x36, 0xcb, 0x0b, 0x46, 0xcb, 0x42, 0xf7, 0x61, 0xd1, 0x25, 0x3d, 0xdb,
0xc2, 0x2e, 0xb5, 0x29, 0x0b, 0xc4, 0x03, 0x79, 0x5d, 0x2a, 0xbb, 0xa4, 0x25, 0xb9, 0x2f, 0x82,
0x81, 0xfe, 0x95, 0x06, 0x95, 0x2e, 0xf1, 0xf8, 0x7d, 0x3d, 0xf8, 0xef, 0xa8, 0x4b, 0x72, 0x57,
0xaa, 0x4b, 0x62, 0x95, 0xc1, 0xef, 0x35, 0xb8, 0x16, 0x99, 0xad, 0x74, 0xba, 0xd7, 0xf4, 0x1f,
0x76, 0x5f, 0x23, 0xc7, 0x72, 0x0e, 0xf7, 0xa6, 0x43, 0xc0, 0xd9, 0x71, 0x42, 0x87, 0xad, 0x6d,
0x70, 0xc7, 0x5b, 0x87, 0x2c, 0x7f, 0x8a, 0x52, 0x9e, 0x37, 0x1d, 0x7c, 0xb8, 0xbc, 0xa8, 0x08,
0x24, 0x34, 0xe6, 0x80, 0x7f, 0xd3, 0x00, 0x26, 0x10, 0xb4, 0x1e, 0x4b, 0x00, 0xef, 0x9e, 0xa3,
0x6d, 0x12, 0xf8, 0x51, 0x2d, 0x12, 0xf0, 0xc5, 0x3e, 0x85, 0x74, 0xed, 0xc7, 0x9a, 0x48, 0x0a,
0x4b, 0x90, 0xe1, 0xa3, 0xab, 0x3b, 0x12, 0x27, 0x2e, 0xde, 0xe4, 0xd8, 0x25, 0x3e, 0x7b, 0xf6,
0x12, 0x7f, 0xf5, 0xc8, 0xbb, 0xf6, 0x65, 0x16, 0x52, 0x9b, 0x9e, 0x8d, 0x3e, 0x83, 0x62, 0xa4,
0x58, 0x43, 0x77, 0xce, 0x2f, 0xe5, 0xb8, 0x4b, 0xd7, 0xee, 0x5e, 0xa6, 0xde, 0xd3, 0x13, 0x68,
0x07, 0x32, 0x3c, 0xca, 0xa0, 0x77, 0xe6, 0x45, 0x1f, 0xa1, 0xef, 0xe6, 0xf9, 0xc1, 0x49, 0x4f,
0xa0, 0x2e, 0x14, 0x42, 0x17, 0x40, 0xb7, 0xcf, 0x73, 0x0f, 0xa1, 0x51, 0xbf, 0xd8, 0x83, 0xf4,
0x04, 0xfa, 0x04, 0xf2, 0xea, 0x9f, 0x7b, 0x74, 0x6b, 0x4a, 0xe2, 0xcc, 0x97, 0x04, 0xb5, 0xdb,
0xe7, 0x20, 0x42, 0x95, 0xdf, 0x87, 0x52, 0xf4, 0x63, 0x08, 0x74, 0x77, 0xa6, 0xd0, 0x99, 0x0f,
0x2c, 0x6a, 0xf7, 0x2e, 0x40, 0x85, 0xea, 0xb7, 0x21, 0xd5, 0x35, 0x3d, 0xf4, 0xd6, 0xac, 0x07,
0x0d, 0xa5, 0xec, 0xcd, 0xb9, 0xaf, 0x1d, 0x7a, 0xea, 0x87, 0x49, 0x6d, 0x55, 0x43, 0x2f, 0xa1,
0x1c, 0xfb, 0x2f, 0x0a, 0xdd, 0xbb, 0xd4, 0x7f, 0x55, 0xe7, 0x69, 0x4e, 0xac, 0x6a, 0x68, 0x13,
0x72, 0xea, 0xbf, 0xe8, 0x39, 0x51, 0xa8, 0xf6, 0xf6, 0x14, 0x3f, 0xf2, 0x89, 0x8b, 0x9e, 0x40,
0x0e, 0x14, 0x3a, 0xd8, 0x39, 0xdc, 0x3a, 0xc2, 0xfd, 0x63, 0xf4, 0xff, 0x13, 0xb0, 0xf8, 0x84,
0xa6, 0x1e, 0xfd, 0x84, 0x26, 0xc4, 0x29, 0xeb, 0xea, 0x97, 0x85, 0x87, 0xab, 0xf9, 0x14, 0xb2,
0x5b, 0xfc, 0xd3, 0x9b, 0xb9, 0xf6, 0x2e, 0x45, 0x75, 0xf2, 0x8f, 0x74, 0x36, 0x1d, 0x47, 0x4f,
0x34, 0xd6, 0x3f, 0x7b, 0x34, 0xb0, 0xe9, 0xd1, 0xe8, 0x80, 0x0d, 0xb5, 0x22, 0x31, 0xea, 0x77,
0x6d, 0x65, 0xf2, 0xe5, 0xc0, 0xca, 0x00, 0xbb, 0x2b, 0x42, 0xe5, 0x41, 0x96, 0xbf, 0xf5, 0xac,
0xff, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xf0, 0xd3, 0x4e, 0x94, 0x50, 0x24, 0x00, 0x00,
// 3146 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x73, 0x1b, 0xc7,
0xb1, 0xc7, 0xe2, 0x1b, 0x0d, 0x90, 0x84, 0x46, 0xb4, 0x1e, 0x0c, 0xdb, 0xb2, 0xb4, 0xfa, 0x30,
0x9f, 0xf4, 0x1e, 0x48, 0x51, 0x96, 0x2c, 0x59, 0xf6, 0x7b, 0x21, 0x48, 0x58, 0x64, 0x22, 0x91,
0xf0, 0x00, 0x8a, 0xab, 0x5c, 0x4e, 0xa1, 0x96, 0xd8, 0x21, 0xb8, 0xe1, 0x62, 0x67, 0xb5, 0x3b,
0x10, 0x8d, 0xff, 0x20, 0x55, 0xa9, 0x54, 0x4e, 0x39, 0xe7, 0x90, 0x53, 0x52, 0xb9, 0xe4, 0x92,
0x8b, 0x6f, 0xb9, 0xe6, 0x9c, 0x4a, 0xe5, 0x92, 0xdc, 0x72, 0x71, 0xe5, 0x96, 0x53, 0x0e, 0xae,
0xd4, 0x7c, 0x2d, 0x76, 0x09, 0x80, 0x1f, 0x72, 0x0e, 0xc9, 0x09, 0xd3, 0x3d, 0xbf, 0xee, 0xe9,
0x99, 0xe9, 0xe9, 0xee, 0x19, 0x2c, 0x54, 0xfc, 0xd1, 0xbe, 0xeb, 0xf4, 0x1b, 0x7e, 0x40, 0x19,
0x45, 0x4b, 0xae, 0xe3, 0x1d, 0x91, 0xc0, 0x5e, 0x6f, 0x48, 0x76, 0xfd, 0xea, 0x80, 0xd2, 0x81,
0x4b, 0x56, 0x45, 0xf7, 0xfe, 0xe8, 0x60, 0xd5, 0x1e, 0x05, 0x16, 0x73, 0xa8, 0x27, 0x05, 0xea,
0xb5, 0x3e, 0x1d, 0x0e, 0xa9, 0xb7, 0x7a, 0x48, 0x2c, 0x97, 0x1d, 0xf6, 0x0f, 0x49, 0xff, 0x48,
0xf5, 0x5c, 0xee, 0x53, 0xef, 0xc0, 0x19, 0xac, 0xca, 0x1f, 0xc9, 0x34, 0x0b, 0x90, 0x6b, 0x0d,
0x7d, 0x36, 0x36, 0x5f, 0x42, 0xf9, 0xfb, 0x24, 0x08, 0x1d, 0xea, 0xed, 0x78, 0x07, 0x14, 0xbd,
0x0d, 0xa5, 0x01, 0x55, 0x8c, 0x9a, 0x71, 0xcd, 0x58, 0x29, 0xe1, 0x09, 0x83, 0xf7, 0xee, 0x8f,
0x1c, 0xd7, 0xde, 0xb2, 0x18, 0xa9, 0xa5, 0x65, 0x6f, 0xc4, 0x40, 0xb7, 0x61, 0x31, 0x20, 0x2e,
0xb1, 0x42, 0xa2, 0x15, 0x64, 0x04, 0xe4, 0x04, 0xd7, 0xbc, 0x0f, 0x97, 0x9f, 0x39, 0x21, 0xeb,
0x90, 0xe0, 0x95, 0xd3, 0x27, 0x21, 0x26, 0x2f, 0x47, 0x24, 0x64, 0x5c, 0xb9, 0x67, 0x0d, 0x49,
0xe8, 0x5b, 0x7d, 0xa2, 0x87, 0x8e, 0x18, 0xe6, 0x33, 0x58, 0x4e, 0x0a, 0x85, 0x3e, 0xf5, 0x42,
0x82, 0xde, 0x87, 0x62, 0xa8, 0x78, 0x35, 0xe3, 0x5a, 0x66, 0xa5, 0xbc, 0x5e, 0x6b, 0x9c, 0x58,
0xbb, 0x86, 0x12, 0xc2, 0x11, 0xd2, 0x7c, 0x02, 0x05, 0xc5, 0x44, 0x08, 0xb2, 0x7c, 0x14, 0x35,
0xa2, 0x68, 0x27, 0x4d, 0x49, 0x9f, 0x34, 0x25, 0x84, 0x25, 0x6e, 0x4a, 0x9b, 0xda, 0x91, 0xed,
0xd7, 0xa6, 0x6c, 0x6f, 0xa6, 0x6b, 0x46, 0x4c, 0x08, 0xfd, 0x1f, 0xb7, 0xd3, 0x25, 0x7d, 0x46,
0x03, 0xa1, 0xb1, 0xbc, 0x6e, 0x4e, 0xd9, 0x89, 0x49, 0x48, 0x47, 0x41, 0x9f, 0x74, 0x04, 0xd0,
0xa1, 0x1e, 0x8e, 0x64, 0xcc, 0x8f, 0xa0, 0x3a, 0x19, 0x54, 0xcd, 0x7d, 0x05, 0xb2, 0x3e, 0xb5,
0xf5, 0xbc, 0x97, 0xa7, 0xf4, 0xb5, 0xa9, 0x8d, 0x05, 0xc2, 0xfc, 0x47, 0x16, 0x32, 0x6d, 0x6a,
0xcf, 0x9c, 0xec, 0x32, 0xe4, 0x7c, 0x6a, 0xef, 0xb4, 0xd5, 0x44, 0x25, 0x81, 0xae, 0x01, 0xd8,
0xc4, 0x77, 0xe9, 0x78, 0x48, 0x3c, 0x26, 0x37, 0x72, 0x3b, 0x85, 0x63, 0x3c, 0x74, 0x1d, 0xca,
0x01, 0xf1, 0x5d, 0xa7, 0x6f, 0xf5, 0x42, 0xc2, 0x6a, 0xa0, 0x21, 0x8a, 0xd9, 0x21, 0x0c, 0x7d,
0x00, 0x57, 0x14, 0xc5, 0x67, 0xd3, 0xeb, 0x53, 0x8f, 0x05, 0xd4, 0x75, 0x49, 0x50, 0x2b, 0x2b,
0xf4, 0x1b, 0xb1, 0xfe, 0xcd, 0xa8, 0x1b, 0xdd, 0x80, 0x4a, 0xc8, 0x2c, 0x46, 0x0e, 0x46, 0xae,
0x50, 0x5e, 0x51, 0xf0, 0xb2, 0xe6, 0x72, 0xed, 0xef, 0x02, 0xd8, 0x16, 0x19, 0x52, 0x4f, 0x40,
0x16, 0x14, 0xa4, 0x24, 0x79, 0x1c, 0x80, 0x20, 0xf3, 0x43, 0xba, 0x5f, 0x5b, 0x54, 0x3d, 0x9c,
0x40, 0x57, 0x20, 0xcf, 0x75, 0x8c, 0xc2, 0x5a, 0x56, 0x4c, 0x57, 0x51, 0x7c, 0x15, 0x2c, 0xdb,
0x26, 0x76, 0x2d, 0x77, 0xcd, 0x58, 0x29, 0x62, 0x49, 0xa0, 0x4d, 0x58, 0x0a, 0x1d, 0xaf, 0x4f,
0x9e, 0x59, 0x21, 0xc3, 0xc4, 0xa7, 0x01, 0xab, 0xe5, 0xc5, 0xe6, 0xbd, 0xd9, 0x90, 0xe7, 0xb1,
0xa1, 0xcf, 0x63, 0x63, 0x4b, 0x9d, 0x47, 0x7c, 0x52, 0x02, 0xad, 0xc1, 0xe5, 0xc9, 0xcc, 0x77,
0x23, 0x37, 0x29, 0x88, 0xf1, 0x67, 0x75, 0x21, 0x13, 0x2a, 0x8a, 0xdd, 0x76, 0x2d, 0x8f, 0xd4,
0x8a, 0xc2, 0xa6, 0x04, 0x0f, 0xdd, 0x83, 0xfc, 0xc8, 0x67, 0xce, 0x90, 0xd4, 0x4a, 0x67, 0x59,
0xa4, 0x80, 0xe8, 0x2a, 0x80, 0x1f, 0xd0, 0x2f, 0xc7, 0x98, 0x58, 0xf6, 0xb8, 0xb6, 0x24, 0x94,
0xc6, 0x38, 0x7c, 0x58, 0x41, 0xe9, 0xe3, 0x5b, 0x15, 0x16, 0x26, 0x78, 0x68, 0x05, 0x96, 0x02,
0xe5, 0xa6, 0x1a, 0x76, 0x49, 0xc0, 0x4e, 0xb2, 0x9b, 0x05, 0xc8, 0xd1, 0x63, 0x8f, 0x04, 0xe6,
0xaf, 0xd2, 0x00, 0x5d, 0xcb, 0xd7, 0x67, 0x05, 0x41, 0xc6, 0xa7, 0xb6, 0x74, 0x41, 0xbe, 0x2b,
0x3e, 0xb5, 0x4f, 0x78, 0x5b, 0x7a, 0x86, 0xb7, 0x5d, 0x81, 0xfc, 0xd0, 0xfa, 0x12, 0xfb, 0xa1,
0xf0, 0xc5, 0x34, 0x56, 0x14, 0xe7, 0x33, 0xda, 0xe6, 0x1b, 0xc3, 0xf7, 0x73, 0x01, 0x2b, 0x8a,
0x7b, 0x3a, 0xa3, 0x3b, 0x6d, 0xb1, 0x9d, 0x25, 0x2c, 0xda, 0xa8, 0x0e, 0xc5, 0x83, 0x80, 0x0e,
0xdb, 0x7a, 0x1b, 0x17, 0x70, 0x44, 0x73, 0x3d, 0xbc, 0xbd, 0xd3, 0x56, 0xfb, 0xa2, 0x28, 0xe1,
0x2f, 0xfd, 0x43, 0x32, 0x94, 0x9b, 0xc0, 0xfd, 0x45, 0x50, 0xc2, 0x1e, 0xc2, 0x0e, 0xa9, 0x2d,
0x96, 0xbf, 0x84, 0x15, 0xc5, 0x43, 0x87, 0x35, 0x62, 0x87, 0x34, 0x70, 0xd8, 0x58, 0x9e, 0x09,
0x3c, 0x61, 0x70, 0xab, 0x7c, 0x8b, 0x1d, 0x4a, 0xf7, 0xc7, 0xa2, 0xfd, 0x61, 0xba, 0x66, 0x34,
0x8b, 0x90, 0x67, 0x56, 0x30, 0x20, 0xcc, 0xfc, 0x6b, 0x0e, 0x96, 0xbb, 0x96, 0xdf, 0x1c, 0xeb,
0x60, 0xa0, 0x97, 0xed, 0x43, 0x0d, 0x11, 0x2b, 0x77, 0xbe, 0xf0, 0xa1, 0x24, 0xd0, 0x06, 0xe4,
0x86, 0x16, 0xeb, 0x1f, 0xaa, 0xc8, 0x73, 0x77, 0x4a, 0x74, 0xd6, 0x88, 0x8d, 0xe7, 0x5c, 0x04,
0x4b, 0xc9, 0x79, 0xeb, 0x5f, 0xff, 0x6d, 0x16, 0x72, 0x02, 0x88, 0x36, 0x21, 0x63, 0xb9, 0xae,
0xb2, 0x6e, 0xf5, 0x02, 0x43, 0x34, 0x3a, 0xe4, 0x25, 0x77, 0x04, 0xcb, 0x75, 0x85, 0x12, 0x6f,
0xac, 0xec, 0x7c, 0x2d, 0x25, 0xde, 0x18, 0xfd, 0x3f, 0x64, 0x3c, 0x2a, 0x83, 0xd6, 0xc5, 0x26,
0xcb, 0x15, 0x78, 0x94, 0xa1, 0x6d, 0xa8, 0xd8, 0x24, 0x64, 0x8e, 0x27, 0xce, 0x8f, 0x0c, 0x15,
0xe7, 0x5a, 0xf1, 0xed, 0x14, 0x4e, 0x48, 0xa2, 0x4f, 0x20, 0x7b, 0xc8, 0x98, 0x2f, 0xdc, 0xb0,
0xbc, 0xbe, 0x76, 0x91, 0x09, 0x6d, 0x33, 0xe6, 0x6f, 0xa7, 0xb0, 0x90, 0xaf, 0x3f, 0x83, 0x4c,
0x87, 0xbc, 0x44, 0x2d, 0x28, 0x88, 0xed, 0x88, 0x92, 0xdd, 0x85, 0xb6, 0x52, 0xcb, 0xd6, 0xc7,
0x90, 0xe5, 0xda, 0x51, 0x2d, 0x72, 0x6e, 0x7d, 0x1a, 0xb5, 0x7b, 0xd7, 0x22, 0xf7, 0xd6, 0x87,
0x51, 0x3b, 0xf8, 0xd5, 0xb8, 0x83, 0xeb, 0xbc, 0x10, 0x73, 0xf1, 0x65, 0xe5, 0xe2, 0x59, 0xd5,
0x25, 0x28, 0x1e, 0x0c, 0xc4, 0xe0, 0x51, 0xc3, 0xfc, 0xbb, 0x01, 0xc0, 0x8d, 0x78, 0x2e, 0xd5,
0x6e, 0x03, 0x04, 0x64, 0xe0, 0x84, 0x8c, 0x04, 0x44, 0x06, 0x87, 0xc5, 0xf5, 0xdb, 0x53, 0x93,
0x9b, 0x08, 0x34, 0x70, 0x84, 0x96, 0x49, 0x47, 0x53, 0xe8, 0x26, 0x54, 0x46, 0x5e, 0x4c, 0x97,
0x9e, 0x40, 0x82, 0x6b, 0x7a, 0x00, 0x13, 0x0d, 0xa8, 0x00, 0x99, 0xa7, 0xad, 0x6e, 0x35, 0x85,
0x8a, 0x90, 0x6d, 0xef, 0x75, 0xba, 0x55, 0x83, 0xb3, 0xda, 0x2f, 0xba, 0xd5, 0x34, 0x02, 0xc8,
0x6f, 0xb5, 0x9e, 0xb5, 0xba, 0xad, 0x6a, 0x06, 0x95, 0x20, 0xd7, 0xde, 0xe8, 0x6e, 0x6e, 0x57,
0xb3, 0xa8, 0x0c, 0x85, 0xbd, 0x76, 0x77, 0x67, 0x6f, 0xb7, 0x53, 0xcd, 0x71, 0x62, 0x73, 0x6f,
0x77, 0xb7, 0xb5, 0xd9, 0xad, 0xe6, 0xb9, 0x8e, 0xed, 0xd6, 0xc6, 0x56, 0xb5, 0xc0, 0xe1, 0x5d,
0xbc, 0xb1, 0xd9, 0xaa, 0x16, 0x9b, 0x79, 0xc8, 0xb2, 0xb1, 0x4f, 0xcc, 0x9f, 0x1b, 0x90, 0xef,
0xc8, 0x35, 0xde, 0x9a, 0x31, 0xe5, 0x69, 0x1f, 0x93, 0xe0, 0x6f, 0x3b, 0xdd, 0xeb, 0x89, 0xe9,
0x72, 0x0b, 0xbb, 0xdd, 0x76, 0x35, 0xc5, 0x2d, 0xe4, 0xad, 0x4e, 0xd5, 0x88, 0x2c, 0xec, 0x42,
0x69, 0xa7, 0xbd, 0x61, 0xdb, 0x01, 0x09, 0x79, 0x5a, 0xcc, 0x3a, 0xfe, 0xab, 0xf7, 0x85, 0x75,
0x05, 0xbe, 0x9b, 0x9c, 0x42, 0x77, 0x05, 0xf7, 0xa1, 0x3a, 0xa6, 0x6f, 0x4c, 0xd9, 0xbc, 0xd3,
0x7e, 0xf5, 0x50, 0x81, 0x1f, 0x36, 0xb3, 0x90, 0x76, 0x7c, 0x73, 0x0d, 0xb2, 0x9c, 0xcb, 0xf3,
0xec, 0x81, 0x13, 0x84, 0x32, 0x8a, 0xe5, 0xb1, 0x24, 0x78, 0x5c, 0x74, 0xad, 0x50, 0x46, 0xfe,
0x3c, 0x16, 0x6d, 0xf3, 0x19, 0x40, 0xb7, 0xef, 0x6b, 0x43, 0xee, 0x70, 0x2d, 0x2a, 0xb8, 0xd4,
0x67, 0x0c, 0xa8, 0x70, 0x38, 0xed, 0xf8, 0x22, 0xca, 0xf2, 0x18, 0x9f, 0x16, 0x31, 0x5e, 0xb4,
0x4d, 0x1b, 0x32, 0x2d, 0xca, 0xd5, 0x54, 0x07, 0x81, 0xdf, 0xef, 0xc9, 0xac, 0xdf, 0xeb, 0x53,
0x5b, 0xfa, 0xfe, 0xc2, 0x76, 0x0a, 0x2f, 0xf2, 0x9e, 0x8e, 0xe8, 0xd8, 0xa4, 0x36, 0xe1, 0xd8,
0x80, 0x84, 0x84, 0xf5, 0x48, 0x10, 0xd0, 0x40, 0x62, 0xd3, 0x1a, 0x2b, 0x7a, 0x5a, 0xbc, 0x83,
0x63, 0x9b, 0x39, 0xc8, 0x10, 0xcf, 0x36, 0xff, 0xb0, 0x08, 0xc5, 0xae, 0xe5, 0xb7, 0x5e, 0xf1,
0x94, 0x75, 0x1f, 0xf2, 0xf2, 0x14, 0x2a, 0xb3, 0xdf, 0x9a, 0x3e, 0xab, 0xd1, 0xfc, 0xb0, 0x82,
0xa2, 0xa7, 0x50, 0x96, 0xad, 0xde, 0x90, 0x30, 0x4b, 0xc5, 0x8d, 0xdb, 0xb3, 0x4e, 0xb9, 0x18,
0xa4, 0xd1, 0xf2, 0x6c, 0x9f, 0x3a, 0x1e, 0x7b, 0x4e, 0x98, 0x85, 0x41, 0x8a, 0xf2, 0x36, 0xfa,
0x18, 0xca, 0xb1, 0x48, 0xa4, 0xb6, 0xea, 0x54, 0x13, 0xe2, 0x78, 0xf4, 0x29, 0x54, 0x63, 0xa4,
0x34, 0x26, 0x7b, 0x21, 0x63, 0x96, 0x62, 0xf2, 0xc2, 0xa2, 0x26, 0x40, 0x40, 0x47, 0x4c, 0xcd,
0xac, 0x20, 0x94, 0xdd, 0x98, 0xaf, 0x0c, 0x73, 0xac, 0xd0, 0x54, 0x0a, 0x74, 0x13, 0x7d, 0x0a,
0x4b, 0xa2, 0x1c, 0xe9, 0xd9, 0x4e, 0x20, 0x43, 0xae, 0xc8, 0xe4, 0x8b, 0xeb, 0x2b, 0xf3, 0x15,
0xb5, 0xb9, 0xc0, 0x96, 0xc6, 0xe3, 0x45, 0x3f, 0x41, 0xa3, 0xf7, 0x55, 0x88, 0x96, 0xe9, 0xe2,
0xea, 0x7c, 0x3d, 0x89, 0x80, 0xfc, 0x33, 0x03, 0x2a, 0xf1, 0xe9, 0xa2, 0xef, 0x42, 0xde, 0xb5,
0xf6, 0x89, 0xab, 0x23, 0xf3, 0xfa, 0xf9, 0x96, 0xa9, 0xf1, 0x4c, 0x08, 0xb5, 0x3c, 0x16, 0x8c,
0xb1, 0xd2, 0x50, 0x7f, 0x0c, 0xe5, 0x18, 0x1b, 0x55, 0x21, 0x73, 0x44, 0xc6, 0xaa, 0x68, 0xe7,
0x4d, 0x7e, 0x8a, 0x5e, 0x59, 0xee, 0x48, 0x5f, 0x4e, 0x24, 0xf1, 0x61, 0xfa, 0x91, 0x51, 0xff,
0xa9, 0x01, 0xa5, 0x68, 0xe5, 0xd0, 0xd3, 0x13, 0x46, 0xad, 0x9e, 0x63, 0xb9, 0xff, 0xd5, 0x16,
0x7d, 0x53, 0x50, 0xd9, 0x66, 0x0f, 0x2a, 0x81, 0xcc, 0x47, 0x3d, 0xc7, 0x73, 0x74, 0x1d, 0x73,
0xe7, 0xf4, 0x05, 0x6f, 0xa8, 0x14, 0xb6, 0xe3, 0x39, 0x8c, 0x5f, 0x00, 0x82, 0x09, 0x89, 0x30,
0x2c, 0x04, 0xea, 0x2e, 0x24, 0x35, 0x9e, 0x52, 0xde, 0x24, 0x34, 0x4a, 0x19, 0xa5, 0xb2, 0x12,
0xc4, 0x68, 0x69, 0xa4, 0xd2, 0x49, 0x3c, 0x5b, 0x79, 0xc5, 0x9d, 0x73, 0xaa, 0x6c, 0x79, 0xb6,
0x34, 0x32, 0x22, 0xeb, 0x0f, 0xa1, 0xd8, 0x61, 0x01, 0xb1, 0x86, 0x3b, 0xe2, 0xfa, 0xb5, 0x6f,
0x85, 0x2a, 0xe2, 0x60, 0xd1, 0x96, 0x17, 0x12, 0xde, 0x2f, 0xac, 0xcf, 0x62, 0x45, 0xd5, 0xff,
0x6c, 0x40, 0x39, 0x36, 0x77, 0xf4, 0x01, 0xa4, 0x1d, 0x5b, 0xad, 0xd9, 0x7b, 0x67, 0x98, 0xa3,
0x07, 0xc4, 0x69, 0xc7, 0xe6, 0x61, 0x28, 0x96, 0xca, 0x67, 0xc5, 0x80, 0x49, 0x56, 0x8d, 0xb2,
0xfc, 0x6a, 0x54, 0x19, 0xc8, 0x05, 0xf8, 0xaf, 0x39, 0x79, 0x29, 0x2a, 0x18, 0x12, 0x75, 0x6f,
0x76, 0x5e, 0xdd, 0x9b, 0x9b, 0xd4, 0xbd, 0xf5, 0xdf, 0x18, 0x50, 0x89, 0x6f, 0xc5, 0xeb, 0xcf,
0xf0, 0x29, 0x20, 0x71, 0xe7, 0xea, 0x25, 0xdc, 0x2b, 0x7d, 0xd6, 0xb5, 0xa8, 0x2a, 0x84, 0xe2,
0x6b, 0xfc, 0x2e, 0x94, 0xf9, 0xe1, 0x56, 0xd9, 0x41, 0x4c, 0x7d, 0x01, 0x03, 0x67, 0xc9, 0xb4,
0x50, 0xff, 0x65, 0x9a, 0x6f, 0x4a, 0xb4, 0xb9, 0xff, 0x06, 0x26, 0xef, 0xc0, 0x65, 0xad, 0x28,
0x7e, 0x12, 0x32, 0x67, 0x69, 0xba, 0xa4, 0x34, 0xc5, 0xd6, 0xff, 0x16, 0x2c, 0x46, 0x4a, 0xf6,
0xc7, 0x8c, 0xc8, 0xba, 0x37, 0x8b, 0xa3, 0x43, 0xd6, 0xe4, 0x4c, 0x74, 0x1b, 0x32, 0x84, 0x86,
0x2a, 0x33, 0x4d, 0x3f, 0x3a, 0xb4, 0x68, 0x88, 0x39, 0x80, 0x57, 0x7a, 0x84, 0xcf, 0xde, 0x7c,
0x04, 0x8b, 0xc9, 0x10, 0xcc, 0xcb, 0xa5, 0x17, 0xbb, 0xdf, 0xdb, 0xdd, 0xfb, 0x6c, 0xb7, 0x9a,
0xe2, 0xc4, 0xce, 0x6e, 0x73, 0xef, 0xc5, 0xee, 0x56, 0xd5, 0x40, 0x15, 0x28, 0xee, 0xbd, 0xe8,
0x4a, 0x2a, 0x3d, 0x51, 0x71, 0x0d, 0x8a, 0x1b, 0xbe, 0x23, 0xd2, 0x2d, 0x8f, 0x34, 0x22, 0x21,
0xab, 0xe8, 0x23, 0x09, 0x7e, 0xc9, 0x2c, 0xb5, 0xa9, 0x2d, 0x20, 0x21, 0x7a, 0x02, 0x79, 0xc1,
0xd6, 0x71, 0xef, 0xc6, 0xac, 0xb7, 0x11, 0x89, 0x8d, 0x5a, 0x58, 0x89, 0xd4, 0xff, 0x62, 0x40,
0x51, 0x33, 0x11, 0x86, 0x12, 0xbf, 0x76, 0x5b, 0x8e, 0x47, 0x02, 0xb5, 0xd1, 0xeb, 0xe7, 0x50,
0xd6, 0xd8, 0xd4, 0x42, 0x82, 0xe4, 0x25, 0x72, 0xa4, 0xa6, 0xfe, 0x0a, 0x16, 0x93, 0xdd, 0xa8,
0x06, 0x85, 0x21, 0x09, 0x43, 0x6b, 0xa0, 0x9f, 0x66, 0x34, 0xc9, 0xcf, 0xd5, 0x64, 0x7c, 0xf5,
0x14, 0x15, 0x31, 0xf8, 0x5a, 0x38, 0x43, 0x2e, 0x25, 0x5f, 0xda, 0x24, 0xc1, 0x43, 0x4a, 0x40,
0xac, 0x90, 0x7a, 0xfa, 0x8d, 0x43, 0x52, 0x62, 0x39, 0xc5, 0x62, 0xb5, 0xa1, 0xa8, 0x6f, 0x08,
0xa7, 0x3f, 0xbb, 0x89, 0x6b, 0xf4, 0xd8, 0xd7, 0x51, 0x5d, 0xb4, 0xa3, 0x47, 0xa4, 0xcc, 0xe4,
0x11, 0xc9, 0x7c, 0x09, 0x97, 0xa6, 0x2e, 0x43, 0xe8, 0x01, 0x14, 0xf5, 0xa3, 0x80, 0x5a, 0xba,
0x37, 0xe7, 0x5e, 0xa1, 0x70, 0x04, 0xe5, 0x7e, 0x28, 0xb2, 0x4e, 0x2f, 0xf1, 0x60, 0x56, 0xc2,
0x0b, 0x82, 0xdb, 0xd1, 0x2f, 0x62, 0x5f, 0xc0, 0x82, 0x16, 0x96, 0x8b, 0xf8, 0x9a, 0xc3, 0x45,
0xfe, 0x94, 0x8e, 0xfb, 0xd3, 0xd7, 0x69, 0x40, 0xfc, 0xd0, 0x77, 0x46, 0xc3, 0xa1, 0x15, 0x8c,
0xf5, 0x2d, 0x3c, 0xfe, 0x8c, 0x67, 0x5c, 0xfc, 0x19, 0x8f, 0x47, 0x18, 0xe6, 0x0c, 0x49, 0xef,
0xd8, 0xf1, 0x6c, 0x7a, 0xac, 0x86, 0x04, 0xce, 0xfa, 0x4c, 0x70, 0xd0, 0xff, 0x40, 0xd6, 0xa3,
0x9e, 0x0e, 0xbb, 0x57, 0xa6, 0x8f, 0xd7, 0xd0, 0x67, 0x63, 0x5e, 0x85, 0x70, 0x14, 0xfa, 0x08,
0xca, 0x8c, 0xf6, 0xa2, 0x59, 0x67, 0xcf, 0x98, 0x35, 0xbf, 0x3a, 0x30, 0x1a, 0x6d, 0xfd, 0x77,
0x60, 0xe1, 0x20, 0xa0, 0xc3, 0x89, 0x7c, 0xee, 0x6c, 0xf9, 0x0a, 0x97, 0x88, 0x34, 0xbc, 0x03,
0x10, 0x1e, 0x39, 0x32, 0x60, 0x86, 0xa2, 0x12, 0x2b, 0xe2, 0x12, 0xe7, 0xf0, 0xa5, 0x0b, 0xd1,
0x5b, 0x50, 0x62, 0x7d, 0xdd, 0x5b, 0x10, 0xbd, 0x45, 0xd6, 0x97, 0x9d, 0x4d, 0x80, 0x22, 0x1d,
0xb1, 0x7d, 0x3a, 0xf2, 0x6c, 0xf3, 0x8f, 0x06, 0x5c, 0x4e, 0xac, 0xb6, 0x7a, 0xe1, 0x7c, 0x0c,
0x69, 0x7a, 0x34, 0x37, 0xbe, 0xce, 0x90, 0x68, 0xec, 0x1d, 0x6d, 0xa7, 0x70, 0x9a, 0x1e, 0xa1,
0x87, 0xf1, 0x6d, 0x9d, 0x55, 0xd7, 0x25, 0x9c, 0x67, 0x3b, 0xa5, 0x36, 0xbe, 0xbe, 0x01, 0xe9,
0xbd, 0x23, 0xf4, 0x04, 0xc4, 0x53, 0x63, 0x8f, 0x59, 0xfb, 0x6e, 0x74, 0xd9, 0xae, 0xcf, 0xb4,
0xa0, 0xcb, 0x21, 0x18, 0x42, 0xdd, 0x14, 0x33, 0xd3, 0x21, 0xd3, 0xfc, 0x75, 0x1a, 0xa0, 0x69,
0x85, 0x4e, 0x5f, 0xae, 0xc8, 0x0d, 0x58, 0x08, 0x47, 0xfd, 0x3e, 0x09, 0xf9, 0xdd, 0x63, 0xe4,
0xc9, 0x22, 0x28, 0x8b, 0x2b, 0x8a, 0xb9, 0xc9, 0x79, 0x1c, 0x74, 0x60, 0x39, 0xee, 0x28, 0x20,
0x0a, 0x24, 0x2b, 0x83, 0x8a, 0x62, 0x4a, 0xd0, 0x4d, 0x7e, 0x4a, 0x18, 0xf1, 0xfa, 0xe3, 0xde,
0x30, 0xec, 0xf9, 0x0f, 0xd6, 0x84, 0xcb, 0x64, 0x71, 0x45, 0x71, 0x9f, 0x87, 0xed, 0x07, 0x6b,
0x27, 0x51, 0x8f, 0x1f, 0xa8, 0x98, 0x1e, 0x43, 0x3d, 0x7e, 0x30, 0x85, 0x7a, 0x2c, 0x3c, 0x21,
0x89, 0x7a, 0x8c, 0xd6, 0x60, 0xd9, 0xea, 0xb3, 0x91, 0xe5, 0xf6, 0x92, 0x53, 0xc8, 0x0b, 0x2c,
0x92, 0x7d, 0x9d, 0xf8, 0x44, 0x26, 0x12, 0xc9, 0xf9, 0x14, 0xe2, 0x12, 0x9f, 0xc4, 0x66, 0x65,
0xfe, 0xd8, 0x80, 0x62, 0x57, 0x79, 0x08, 0xfa, 0x6f, 0xa8, 0x52, 0x9f, 0x88, 0x77, 0x63, 0x4f,
0x9e, 0xa4, 0x50, 0xad, 0xd7, 0x12, 0xe7, 0x6f, 0x4e, 0xd8, 0x68, 0x85, 0xdf, 0xd5, 0x2c, 0x5b,
0xe6, 0xad, 0x1e, 0xa3, 0xcc, 0x72, 0xd5, 0xaa, 0x2d, 0x72, 0xbe, 0xc8, 0x5c, 0x5d, 0xce, 0x45,
0x77, 0xe0, 0xd2, 0x71, 0xe0, 0x30, 0x92, 0x80, 0xca, 0xa5, 0x5b, 0x12, 0x1d, 0x13, 0xac, 0xd9,
0x81, 0x4b, 0xdd, 0xc0, 0x3a, 0x38, 0x70, 0xfa, 0x1d, 0xdf, 0x75, 0x98, 0xb4, 0x0a, 0x41, 0xd6,
0xf2, 0xc9, 0x97, 0x3a, 0x24, 0xf2, 0xb6, 0xb8, 0xbf, 0x12, 0xeb, 0x40, 0x87, 0x44, 0xde, 0xe6,
0x51, 0xf8, 0x98, 0x38, 0x83, 0x43, 0xa6, 0xa3, 0xb0, 0xa4, 0xcc, 0x6f, 0x72, 0x50, 0x8a, 0xfc,
0x06, 0x35, 0xa1, 0xe4, 0x53, 0xbb, 0x37, 0x08, 0xe8, 0x48, 0x5f, 0x6f, 0x6f, 0xcc, 0x77, 0x33,
0x9e, 0x5f, 0x9e, 0x72, 0xe8, 0x76, 0x0a, 0x17, 0x7d, 0xd5, 0xae, 0xff, 0x22, 0x27, 0x12, 0x96,
0x20, 0xd0, 0x13, 0xc8, 0x06, 0xf4, 0x58, 0xbb, 0xec, 0x7b, 0xe7, 0xd0, 0xd5, 0xc0, 0xf4, 0x18,
0x0b, 0xa1, 0xfa, 0x9f, 0xb2, 0x90, 0xc1, 0xf4, 0xf8, 0x75, 0x43, 0xe9, 0x99, 0xd1, 0x6d, 0xf2,
0xfa, 0x5e, 0x4a, 0xbc, 0xbe, 0xaf, 0x40, 0x75, 0x48, 0xc2, 0x43, 0x62, 0xf7, 0xf8, 0x62, 0x48,
0x27, 0x91, 0x7b, 0xb2, 0x28, 0xf9, 0x6d, 0x6a, 0x4b, 0x97, 0xba, 0x03, 0x97, 0x82, 0x91, 0xe7,
0x39, 0xde, 0x20, 0x06, 0x95, 0x3e, 0xbd, 0xa4, 0x3a, 0x22, 0xec, 0x0a, 0x54, 0xb9, 0xdf, 0x25,
0xb4, 0x4a, 0x67, 0x5d, 0x94, 0xfc, 0x08, 0x79, 0x0f, 0x72, 0x32, 0x48, 0xe5, 0xe6, 0x94, 0xc8,
0x93, 0x23, 0x8c, 0x25, 0x12, 0x3d, 0x8c, 0xc7, 0xb6, 0xe2, 0x9c, 0x35, 0xd2, 0xae, 0x3c, 0x09,
0x7b, 0xe8, 0x63, 0x28, 0xb2, 0x50, 0x89, 0xc1, 0x9c, 0x0c, 0x32, 0xe5, 0x74, 0xb8, 0xc0, 0x42,
0x29, 0xfe, 0x05, 0x2c, 0xc8, 0x32, 0xa5, 0xb7, 0x3f, 0xe6, 0xd3, 0xaa, 0x15, 0xc4, 0x3e, 0x3f,
0x3a, 0xe7, 0x3e, 0x37, 0x64, 0x9d, 0xd2, 0x1c, 0xf3, 0x42, 0x45, 0xdc, 0xf0, 0xca, 0x64, 0xc2,
0xa9, 0x7f, 0x0e, 0xd5, 0x93, 0x80, 0x19, 0x77, 0xbd, 0xb5, 0xf8, 0x5d, 0x6f, 0x56, 0x58, 0x8c,
0xea, 0xa1, 0xd8, 0x3d, 0x90, 0x57, 0x1f, 0x22, 0x9a, 0x9a, 0xbb, 0x50, 0x69, 0xd9, 0x83, 0xc9,
0x1f, 0x7f, 0xdf, 0x32, 0xa7, 0x9a, 0x5f, 0x19, 0xb0, 0xa0, 0x14, 0xaa, 0xb4, 0x71, 0x3f, 0x96,
0x36, 0xae, 0x4f, 0xa7, 0xd0, 0x38, 0xf6, 0xdb, 0x27, 0x8c, 0x7b, 0x22, 0x61, 0xdc, 0x85, 0x1c,
0xe1, 0x7a, 0xd5, 0xb9, 0x7b, 0x63, 0xe6, 0xa8, 0x58, 0x62, 0x12, 0x09, 0xe2, 0x77, 0x06, 0x64,
0x79, 0x1f, 0xba, 0x0b, 0x99, 0x30, 0xe8, 0x9f, 0x7d, 0xdc, 0x38, 0x8a, 0x83, 0xed, 0x70, 0x72,
0x61, 0x98, 0x0f, 0xb6, 0x43, 0xc6, 0xd3, 0x70, 0xdf, 0x75, 0x88, 0xc7, 0x7a, 0x8e, 0xad, 0x42,
0x54, 0x51, 0x32, 0x76, 0x6c, 0xde, 0x19, 0x92, 0xe0, 0x15, 0x09, 0x78, 0xa7, 0x8c, 0x54, 0x45,
0xc9, 0xd8, 0xb1, 0xd1, 0x6d, 0x58, 0xf2, 0x68, 0xcf, 0xb1, 0x89, 0xc7, 0x1c, 0xc6, 0x93, 0xc3,
0x40, 0x5d, 0xe1, 0x16, 0x3c, 0xba, 0xa3, 0xb8, 0xcf, 0xc3, 0x81, 0xf9, 0xb5, 0x01, 0xd5, 0x2e,
0xf5, 0xc5, 0x1b, 0x42, 0xf8, 0x9f, 0x51, 0x2b, 0x15, 0x2e, 0x54, 0x2b, 0x25, 0xaa, 0x95, 0xdf,
0x1b, 0x70, 0x29, 0x36, 0x5b, 0xe5, 0x74, 0xaf, 0xe9, 0x3f, 0xfc, 0x0e, 0x49, 0x8f, 0xd4, 0x1c,
0x6e, 0x4d, 0x87, 0x82, 0x93, 0xe3, 0x44, 0x0e, 0x5b, 0x7f, 0x2c, 0x1c, 0xef, 0x3e, 0xe4, 0xc5,
0xf3, 0x98, 0xf6, 0xbc, 0xe9, 0xd8, 0x25, 0xe4, 0x65, 0x95, 0xa2, 0xa0, 0x09, 0x07, 0xfc, 0x9b,
0x01, 0x30, 0x81, 0xa0, 0xfb, 0x89, 0xfc, 0xf1, 0xee, 0x29, 0xda, 0x26, 0x79, 0x03, 0xd5, 0x63,
0xf9, 0x42, 0xee, 0x53, 0x44, 0xd7, 0x7f, 0x62, 0xc8, 0x9c, 0xb2, 0x0c, 0x39, 0x31, 0xba, 0xbe,
0xb7, 0x09, 0xe2, 0xec, 0x4d, 0x4e, 0x3c, 0x2c, 0xe4, 0x4f, 0x3e, 0x2c, 0x5c, 0x3c, 0x70, 0xaf,
0x7f, 0x95, 0x87, 0xcc, 0x86, 0xef, 0xa0, 0xcf, 0xa1, 0x1c, 0x2b, 0x20, 0xd1, 0x8d, 0xd3, 0xcb,
0x4b, 0xe1, 0xd2, 0xf5, 0x9b, 0xe7, 0xa9, 0x41, 0xcd, 0x14, 0xda, 0x86, 0x9c, 0x88, 0x32, 0xe8,
0x9d, 0x79, 0xd1, 0x47, 0xea, 0xbb, 0x7a, 0x7a, 0x70, 0x32, 0x53, 0xa8, 0x0b, 0xa5, 0xc8, 0x05,
0xd0, 0xf5, 0xd3, 0xdc, 0x43, 0x6a, 0x34, 0xcf, 0xf6, 0x20, 0x33, 0x85, 0x3e, 0x85, 0xa2, 0xfe,
0x9a, 0x00, 0x5d, 0x9b, 0x92, 0x38, 0xf1, 0x75, 0x43, 0xfd, 0xfa, 0x29, 0x88, 0x48, 0xe5, 0x0f,
0xa0, 0x12, 0xff, 0x40, 0x03, 0xdd, 0x9c, 0x29, 0x74, 0xe2, 0xa3, 0x8f, 0xfa, 0xad, 0x33, 0x50,
0x91, 0xfa, 0x2d, 0xc8, 0x74, 0x2d, 0x1f, 0xbd, 0x35, 0xeb, 0x91, 0x45, 0x2b, 0x7b, 0x73, 0xee,
0x0b, 0x8c, 0x99, 0xf9, 0x51, 0xda, 0x58, 0x33, 0xd0, 0x0b, 0x58, 0x48, 0xfc, 0x3f, 0x86, 0x6e,
0x9d, 0xeb, 0xff, 0xb3, 0xd3, 0x34, 0xa7, 0xd6, 0x0c, 0xb4, 0x01, 0x05, 0xfd, 0xff, 0xf8, 0x9c,
0x28, 0x54, 0x7f, 0x7b, 0x8a, 0x1f, 0xfb, 0xec, 0xc6, 0x4c, 0x21, 0x17, 0x4a, 0x1d, 0xe2, 0x1e,
0x6c, 0x1e, 0x92, 0xfe, 0x11, 0xfa, 0xdf, 0x09, 0x58, 0x7e, 0xd6, 0xd3, 0x88, 0x7f, 0xd6, 0x13,
0xe1, 0xb4, 0x75, 0x8d, 0xf3, 0xc2, 0xa3, 0xd5, 0x7c, 0x04, 0xf9, 0x4d, 0xf1, 0x39, 0xd0, 0x5c,
0x7b, 0x97, 0xe3, 0x3a, 0xc5, 0x87, 0x43, 0x1b, 0xae, 0x6b, 0xa6, 0x9a, 0xf7, 0x3f, 0xbf, 0x37,
0x70, 0xd8, 0xe1, 0x68, 0x9f, 0x0f, 0xb5, 0xaa, 0x30, 0xfa, 0x77, 0x7d, 0x75, 0xf2, 0x35, 0xc3,
0xea, 0x80, 0x78, 0xab, 0x52, 0xe5, 0x7e, 0x5e, 0xbc, 0x3f, 0xdd, 0xff, 0x67, 0x00, 0x00, 0x00,
0xff, 0xff, 0x19, 0x79, 0xb2, 0x41, 0xe4, 0x24, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

6
pkg/k8s/k8s.go
View File

@ -43,6 +43,7 @@ var AllResources = []string{
Service,
ServiceProfile,
StatefulSet,
TrafficSplit,
}
// StatAllResourceTypes represents the resources to query in StatSummary when Resource.Type is "all"
@ -55,6 +56,7 @@ var StatAllResourceTypes = []string{
ReplicationController,
Pod,
Service,
TrafficSplit,
Authority,
}
@ -100,6 +102,8 @@ func CanonicalResourceNameFromFriendlyName(friendlyName string) (string, error)
return ServiceProfile, nil
case "sts", "statefulset", "statefulsets":
return StatefulSet, nil
case "ts", "trafficsplit", "trafficsplits":
return TrafficSplit, nil
case "all":
return All, nil
}
@ -133,6 +137,8 @@ func ShortNameFromCanonicalResourceName(canonicalName string) string {
return "sp"
case StatefulSet:
return "sts"
case TrafficSplit:
return "ts"
default:
return ""
}

7
proto/public.proto
View File

@ -350,6 +350,12 @@ message TcpStats {
uint64 write_bytes_total = 3;
}
message TrafficSplitStats {
string apex = 2;
string leaf = 3;
string weight = 4;
}
message StatTable {
oneof table {
PodGroup pod_group = 1;
@ -373,6 +379,7 @@ message StatTable {
BasicStats stats = 5;
TcpStats tcp_stats = 8;
TrafficSplitStats ts_stats = 10;
// Stores a set of errors for each pod name. If a pod has no errors, it may be omitted.
map<string, PodErrors> errors_by_pod = 7;