diff --git a/Gopkg.lock b/Gopkg.lock index c29818da3..34288f661 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -223,6 +223,23 @@ pruneopts = "NUT" revision = "c3068f13fcc3961fd05f96f13c8250e350db4209" +[[projects]] + digest = "1:3efb665a5beaa0266ff287cdb58dff8a966631000e9f8ad8d832a288b90ca247" + name = "github.com/google/mako" + packages = [ + "clients/proto/analyzers/threshold_analyzer_go_proto", + "clients/proto/analyzers/utest_analyzer_go_proto", + "clients/proto/analyzers/window_deviation_go_proto", + "helpers/go/quickstore", + "helpers/proto/quickstore/quickstore_go_proto", + "internal/go/common", + "internal/quickstore_microservice/proto/quickstore_go_proto", + "spec/proto/mako_go_proto", + ] + pruneopts = "NUT" + revision = "d56a6e811df75f8e4d6e7c256d25acf19ef16d03" + version = "v0.0.0-rc.4" + [[projects]] digest = "1:ab3ec1fe3e39bac4b3ab63390767766622be35b7cab03f47f787f9ec60522a53" name = "github.com/google/uuid" @@ -1229,8 +1246,13 @@ "github.com/evanphx/json-patch", "github.com/ghodss/yaml", "github.com/golang/glog", + "github.com/golang/protobuf/proto", "github.com/google/go-cmp/cmp", "github.com/google/go-cmp/cmp/cmpopts", + "github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto", + "github.com/google/mako/helpers/go/quickstore", + "github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto", + "github.com/google/mako/spec/proto/mako_go_proto", "github.com/google/uuid", "github.com/gorilla/websocket", "github.com/markbates/inflect", diff --git a/test/mako/README.md b/test/mako/README.md new file mode 100644 index 000000000..1bc749fe0 --- /dev/null +++ b/test/mako/README.md @@ -0,0 +1,7 @@ +# Mako + +[Mako](https://github.com/google/mako) is an open source project for performance testing in Knative. +It offers capacities like data storage, charting, statistical aggregation and automated regression analysis. + +This folder contains common code that can be used by all Knative projects, with which we can follow the +same process to set up Mako and collaborate. diff --git a/test/mako/analyzer.go b/test/mako/analyzer.go new file mode 100644 index 000000000..d581543b7 --- /dev/null +++ b/test/mako/analyzer.go @@ -0,0 +1,35 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "github.com/golang/protobuf/proto" + tpb "github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto" + mpb "github.com/google/mako/spec/proto/mako_go_proto" +) + +// NewCrossRunConfig returns a config that can be used in ThresholdAnalyzer. +// By using it, the Analyzer will only fail if there are xx continuous runs that cross the threshold. +func NewCrossRunConfig(runCount int32, tags ...string) *tpb.CrossRunConfig { + return &tpb.CrossRunConfig{ + RunInfoQueryList: []*mpb.RunInfoQuery{{ + Limit: proto.Int32(runCount), + Tags: tags, + }}, + MinRunCount: proto.Int32(runCount), + } +} diff --git a/test/mako/benchmark.go b/test/mako/benchmark.go new file mode 100644 index 000000000..da143e1ee --- /dev/null +++ b/test/mako/benchmark.go @@ -0,0 +1,71 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "fmt" + "io/ioutil" + "log" + "os" + "path/filepath" + + "github.com/golang/protobuf/proto" + mpb "github.com/google/mako/spec/proto/mako_go_proto" +) + +const koDataPathEnvName = "KO_DATA_PATH" + +// MustGetBenchmark wraps getBenchmark in log.Fatalf +func MustGetBenchmark() *string { + b, err := getBenchmark() + if err != nil { + log.Fatalf("unable to determine benchmark_key: %v", err) + } + return b +} + +// getBenchmark fetches the appropriate benchmark_key for this configured environment. +func getBenchmark() (*string, error) { + // Figure out what environment we're running in from the Mako configmap. + env, err := getEnvironment() + if err != nil { + return nil, err + } + // Read the Mako config file for this environment. + data, err := readConfigFromKoData(env) + if err != nil { + return nil, err + } + // Parse the Mako config file. + bi := &mpb.BenchmarkInfo{} + if err := proto.UnmarshalText(string(data), bi); err != nil { + return nil, err + } + + // Return the benchmark_key from this environment's config file. + return bi.BenchmarkKey, nil +} + +// readConfigFromKoData reads the named config file from kodata. +func readConfigFromKoData(environment string) ([]byte, error) { + koDataPath := os.Getenv(koDataPathEnvName) + if koDataPath == "" { + return nil, fmt.Errorf("%q does not exist or is empty", koDataPathEnvName) + } + fullFilename := filepath.Join(koDataPath, environment+".config") + return ioutil.ReadFile(fullFilename) +} diff --git a/test/mako/config.go b/test/mako/config.go new file mode 100644 index 000000000..c3e997407 --- /dev/null +++ b/test/mako/config.go @@ -0,0 +1,60 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "strings" + + corev1 "k8s.io/api/core/v1" +) + +const ( + // ConfigName is the name of the config map for mako options. + ConfigName = "config-mako" +) + +// Config defines the mako configuration options. +type Config struct { + // Environment holds the name of the environement, + // where the test runs, e.g. `dev`. + Environment string + + // List of additional tags to apply to the run. + AdditionalTags []string +} + +// NewConfigFromMap creates a Config from the supplied map +func NewConfigFromMap(data map[string]string) (*Config, error) { + lc := &Config{ + Environment: "dev", + AdditionalTags: []string{}, + } + + if raw, ok := data["environment"]; ok { + lc.Environment = raw + } + if raw, ok := data["additionalTags"]; ok && raw != "" { + lc.AdditionalTags = strings.Split(raw, ",") + } + + return lc, nil +} + +// NewConfigFromConfigMap creates a Config from the supplied ConfigMap +func NewConfigFromConfigMap(configMap *corev1.ConfigMap) (*Config, error) { + return NewConfigFromMap(configMap.Data) +} diff --git a/test/mako/config_test.go b/test/mako/config_test.go new file mode 100644 index 000000000..4d5db9d1e --- /dev/null +++ b/test/mako/config_test.go @@ -0,0 +1,33 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "testing" + + . "knative.dev/pkg/configmap/testing" +) + +func TestOurConfig(t *testing.T) { + cm, example := ConfigMapsFromTestFile(t, ConfigName) + if _, err := NewConfigFromConfigMap(cm); err != nil { + t.Errorf("NewConfigFromConfigMap(actual) = %v", err) + } + if _, err := NewConfigFromConfigMap(example); err != nil { + t.Errorf("NewConfigFromConfigMap(example) = %v", err) + } +} diff --git a/test/mako/environment.go b/test/mako/environment.go new file mode 100644 index 000000000..2b5ecebb9 --- /dev/null +++ b/test/mako/environment.go @@ -0,0 +1,52 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "log" + "path/filepath" + + "knative.dev/pkg/configmap" +) + +// TODO: perhaps cache the loaded CM. + +// MustGetTags returns the additional tags from the configmap, or dies. +func MustGetTags() []string { + makoCM, err := configmap.Load(filepath.Join("/etc", ConfigName)) + if err != nil { + log.Fatalf("unable to load configmap: %v", err) + } + cfg, err := NewConfigFromMap(makoCM) + if err != nil { + log.Fatalf("unable to parse configmap: %v", err) + } + return cfg.AdditionalTags +} + +// getEnvironment fetches the Mako config environment to which this cluster should publish. +func getEnvironment() (string, error) { + makoCM, err := configmap.Load(filepath.Join("/etc", ConfigName)) + if err != nil { + return "", err + } + cfg, err := NewConfigFromMap(makoCM) + if err != nil { + return "", err + } + return cfg.Environment, nil +} diff --git a/test/mako/sidecar.go b/test/mako/sidecar.go new file mode 100644 index 000000000..cbb0fdff8 --- /dev/null +++ b/test/mako/sidecar.go @@ -0,0 +1,96 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "context" + "log" + "runtime" + "strings" + + "cloud.google.com/go/compute/metadata" + "knative.dev/pkg/injection/clients/kubeclient" + + "github.com/google/mako/helpers/go/quickstore" + qpb "github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto" + "k8s.io/client-go/rest" + "knative.dev/pkg/changeset" + "knative.dev/pkg/controller" + "knative.dev/pkg/injection" +) + +const ( + // sidecarAddress is the address of the Mako sidecar to which we locally + // write results, and it authenticates and publishes them to Mako after + // assorted preprocessing. + sidecarAddress = "localhost:9813" +) + +// EscapeTag replaces characters that Mako doesn't accept with ones it does. +func EscapeTag(tag string) string { + return strings.ReplaceAll(tag, ".", "_") +} + +// Setup sets up the mako client for the provided benchmarkKey. +// It will add a few common tags and allow each benchmark to add custm tags as well. +// It returns the mako client handle to store metrics, a method to close the connection +// to mako server once done and error in case of failures. +func Setup(ctx context.Context, extraTags ...string) (context.Context, *quickstore.Quickstore, func(context.Context), error) { + tags := append(MustGetTags(), extraTags...) + // Get the commit of the benchmarks + commitID, err := changeset.Get() + if err != nil { + return nil, nil, nil, err + } + + // Setup a deployment informer, so that we can use the lister to track + // desired and available pod counts. + cfg, err := rest.InClusterConfig() + if err != nil { + return nil, nil, nil, err + } + ctx, informers := injection.Default.SetupInformers(ctx, cfg) + if err := controller.StartInformers(ctx.Done(), informers...); err != nil { + return nil, nil, nil, err + } + + // Get the Kubernetes version from the API server. + version, err := kubeclient.Get(ctx).Discovery().ServerVersion() + if err != nil { + return nil, nil, nil, err + } + + // Get GCP project ID as a tag. + if projectID, err := metadata.ProjectID(); err != nil { + log.Printf("GCP project ID is not available: %v", err) + } else { + tags = append(tags, "project-id="+EscapeTag(projectID)) + } + + qs, qclose, err := quickstore.NewAtAddress(ctx, &qpb.QuickstoreInput{ + BenchmarkKey: MustGetBenchmark(), + Tags: append(tags, + "commit="+commitID, + "kubernetes="+EscapeTag(version.String()), + EscapeTag(runtime.Version()), + ), + }, sidecarAddress) + if err != nil { + return nil, nil, nil, err + } + return ctx, qs, qclose, nil +} diff --git a/test/mako/testdata/config-mako.yaml b/test/mako/testdata/config-mako.yaml new file mode 100644 index 000000000..91b25069c --- /dev/null +++ b/test/mako/testdata/config-mako.yaml @@ -0,0 +1,47 @@ +# Copyright 2019 The Knative 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 +# +# https://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. + +apiVersion: v1 +kind: ConfigMap +metadata: + name: config-mako + +data: + _example: | + ################################ + # # + # EXAMPLE CONFIGURATION # + # # + ################################ + + # This block is not actually functional configuration, + # but serves to illustrate the available configuration + # options and document them in a way that is accessible + # to users that `kubectl edit` this config map. + # + # These sample configuration options may be copied out of + # this example block and unindented to be in the data block + # to actually change the configuration. + + # The Mako environment in which we are running. + # Only our performance automation should run in "prod", but + # there should be a "dev" environment with a fairly broad + # write ACL. Users can also develop against custom configurations + # by adding `foo.config` under their benchmark's kodata directory. + environment: dev + + # Additional tags to tag the runs. These tags are added + # to the list that the binary itself publishes (Kubernetes version, etc). + # It is a comma separated list of tags. + additionalTags: "key=value,absolute" diff --git a/test/mako/time.go b/test/mako/time.go new file mode 100644 index 000000000..1a2f4cab0 --- /dev/null +++ b/test/mako/time.go @@ -0,0 +1,26 @@ +/* +Copyright 2019 The Knative 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 mako + +import ( + "time" +) + +// XTime converts a time.Time into a Mako x-axis compatible timestamp. +func XTime(t time.Time) float64 { + return float64(t.UnixNano()) / (1000.0 * 1000.0) +} diff --git a/vendor/github.com/google/mako/LICENSE b/vendor/github.com/google/mako/LICENSE new file mode 100644 index 000000000..fef7d9678 --- /dev/null +++ b/vendor/github.com/google/mako/LICENSE @@ -0,0 +1,204 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + + \ No newline at end of file diff --git a/vendor/github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto/threshold_analyzer.pb.go b/vendor/github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto/threshold_analyzer.pb.go new file mode 100755 index 000000000..7f9845410 --- /dev/null +++ b/vendor/github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto/threshold_analyzer.pb.go @@ -0,0 +1,420 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: clients/proto/analyzers/threshold_analyzer.proto + +package mako_analyzers_threshold_analyzer + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + mako_go_proto "github.com/google/mako/spec/proto/mako_go_proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type ThresholdConfig struct { + Min *float64 `protobuf:"fixed64,1,opt,name=min" json:"min,omitempty"` + Max *float64 `protobuf:"fixed64,2,opt,name=max" json:"max,omitempty"` + OutlierPercentMax *float64 `protobuf:"fixed64,3,opt,name=outlier_percent_max,json=outlierPercentMax" json:"outlier_percent_max,omitempty"` + DataFilter *mako_go_proto.DataFilter `protobuf:"bytes,4,opt,name=data_filter,json=dataFilter" json:"data_filter,omitempty"` + ConfigName *string `protobuf:"bytes,5,opt,name=config_name,json=configName" json:"config_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ThresholdConfig) Reset() { *m = ThresholdConfig{} } +func (m *ThresholdConfig) String() string { return proto.CompactTextString(m) } +func (*ThresholdConfig) ProtoMessage() {} +func (*ThresholdConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_efc166777e6a25c0, []int{0} +} + +func (m *ThresholdConfig) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ThresholdConfig.Unmarshal(m, b) +} +func (m *ThresholdConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ThresholdConfig.Marshal(b, m, deterministic) +} +func (m *ThresholdConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_ThresholdConfig.Merge(m, src) +} +func (m *ThresholdConfig) XXX_Size() int { + return xxx_messageInfo_ThresholdConfig.Size(m) +} +func (m *ThresholdConfig) XXX_DiscardUnknown() { + xxx_messageInfo_ThresholdConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_ThresholdConfig proto.InternalMessageInfo + +func (m *ThresholdConfig) GetMin() float64 { + if m != nil && m.Min != nil { + return *m.Min + } + return 0 +} + +func (m *ThresholdConfig) GetMax() float64 { + if m != nil && m.Max != nil { + return *m.Max + } + return 0 +} + +func (m *ThresholdConfig) GetOutlierPercentMax() float64 { + if m != nil && m.OutlierPercentMax != nil { + return *m.OutlierPercentMax + } + return 0 +} + +func (m *ThresholdConfig) GetDataFilter() *mako_go_proto.DataFilter { + if m != nil { + return m.DataFilter + } + return nil +} + +func (m *ThresholdConfig) GetConfigName() string { + if m != nil && m.ConfigName != nil { + return *m.ConfigName + } + return "" +} + +type CrossRunConfig struct { + RunInfoQueryList []*mako_go_proto.RunInfoQuery `protobuf:"bytes,1,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"` + MinRunCount *int32 `protobuf:"varint,3,opt,name=min_run_count,json=minRunCount" json:"min_run_count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CrossRunConfig) Reset() { *m = CrossRunConfig{} } +func (m *CrossRunConfig) String() string { return proto.CompactTextString(m) } +func (*CrossRunConfig) ProtoMessage() {} +func (*CrossRunConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_efc166777e6a25c0, []int{1} +} + +func (m *CrossRunConfig) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CrossRunConfig.Unmarshal(m, b) +} +func (m *CrossRunConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CrossRunConfig.Marshal(b, m, deterministic) +} +func (m *CrossRunConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_CrossRunConfig.Merge(m, src) +} +func (m *CrossRunConfig) XXX_Size() int { + return xxx_messageInfo_CrossRunConfig.Size(m) +} +func (m *CrossRunConfig) XXX_DiscardUnknown() { + xxx_messageInfo_CrossRunConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_CrossRunConfig proto.InternalMessageInfo + +func (m *CrossRunConfig) GetRunInfoQueryList() []*mako_go_proto.RunInfoQuery { + if m != nil { + return m.RunInfoQueryList + } + return nil +} + +func (m *CrossRunConfig) GetMinRunCount() int32 { + if m != nil && m.MinRunCount != nil { + return *m.MinRunCount + } + return 0 +} + +type ThresholdAnalyzerInput struct { + Configs []*ThresholdConfig `protobuf:"bytes,1,rep,name=configs" json:"configs,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + HistoricalContextTags []string `protobuf:"bytes,3,rep,name=historical_context_tags,json=historicalContextTags" json:"historical_context_tags,omitempty"` + CrossRunConfig *CrossRunConfig `protobuf:"bytes,4,opt,name=cross_run_config,json=crossRunConfig" json:"cross_run_config,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ThresholdAnalyzerInput) Reset() { *m = ThresholdAnalyzerInput{} } +func (m *ThresholdAnalyzerInput) String() string { return proto.CompactTextString(m) } +func (*ThresholdAnalyzerInput) ProtoMessage() {} +func (*ThresholdAnalyzerInput) Descriptor() ([]byte, []int) { + return fileDescriptor_efc166777e6a25c0, []int{2} +} + +func (m *ThresholdAnalyzerInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ThresholdAnalyzerInput.Unmarshal(m, b) +} +func (m *ThresholdAnalyzerInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ThresholdAnalyzerInput.Marshal(b, m, deterministic) +} +func (m *ThresholdAnalyzerInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_ThresholdAnalyzerInput.Merge(m, src) +} +func (m *ThresholdAnalyzerInput) XXX_Size() int { + return xxx_messageInfo_ThresholdAnalyzerInput.Size(m) +} +func (m *ThresholdAnalyzerInput) XXX_DiscardUnknown() { + xxx_messageInfo_ThresholdAnalyzerInput.DiscardUnknown(m) +} + +var xxx_messageInfo_ThresholdAnalyzerInput proto.InternalMessageInfo + +func (m *ThresholdAnalyzerInput) GetConfigs() []*ThresholdConfig { + if m != nil { + return m.Configs + } + return nil +} + +func (m *ThresholdAnalyzerInput) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ThresholdAnalyzerInput) GetHistoricalContextTags() []string { + if m != nil { + return m.HistoricalContextTags + } + return nil +} + +func (m *ThresholdAnalyzerInput) GetCrossRunConfig() *CrossRunConfig { + if m != nil { + return m.CrossRunConfig + } + return nil +} + +type ThresholdAnalyzerOutput struct { + ConfigResults []*ThresholdConfigResult `protobuf:"bytes,1,rep,name=config_results,json=configResults" json:"config_results,omitempty"` + MinTimestampMs *float64 `protobuf:"fixed64,2,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"` + MaxTimestampMs *float64 `protobuf:"fixed64,3,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"` + MinBuildId *float64 `protobuf:"fixed64,4,opt,name=min_build_id,json=minBuildId" json:"min_build_id,omitempty"` + MaxBuildId *float64 `protobuf:"fixed64,5,opt,name=max_build_id,json=maxBuildId" json:"max_build_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ThresholdAnalyzerOutput) Reset() { *m = ThresholdAnalyzerOutput{} } +func (m *ThresholdAnalyzerOutput) String() string { return proto.CompactTextString(m) } +func (*ThresholdAnalyzerOutput) ProtoMessage() {} +func (*ThresholdAnalyzerOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_efc166777e6a25c0, []int{3} +} + +func (m *ThresholdAnalyzerOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ThresholdAnalyzerOutput.Unmarshal(m, b) +} +func (m *ThresholdAnalyzerOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ThresholdAnalyzerOutput.Marshal(b, m, deterministic) +} +func (m *ThresholdAnalyzerOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_ThresholdAnalyzerOutput.Merge(m, src) +} +func (m *ThresholdAnalyzerOutput) XXX_Size() int { + return xxx_messageInfo_ThresholdAnalyzerOutput.Size(m) +} +func (m *ThresholdAnalyzerOutput) XXX_DiscardUnknown() { + xxx_messageInfo_ThresholdAnalyzerOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_ThresholdAnalyzerOutput proto.InternalMessageInfo + +func (m *ThresholdAnalyzerOutput) GetConfigResults() []*ThresholdConfigResult { + if m != nil { + return m.ConfigResults + } + return nil +} + +func (m *ThresholdAnalyzerOutput) GetMinTimestampMs() float64 { + if m != nil && m.MinTimestampMs != nil { + return *m.MinTimestampMs + } + return 0 +} + +func (m *ThresholdAnalyzerOutput) GetMaxTimestampMs() float64 { + if m != nil && m.MaxTimestampMs != nil { + return *m.MaxTimestampMs + } + return 0 +} + +func (m *ThresholdAnalyzerOutput) GetMinBuildId() float64 { + if m != nil && m.MinBuildId != nil { + return *m.MinBuildId + } + return 0 +} + +func (m *ThresholdAnalyzerOutput) GetMaxBuildId() float64 { + if m != nil && m.MaxBuildId != nil { + return *m.MaxBuildId + } + return 0 +} + +type ThresholdConfigResult struct { + PercentAboveMax *float64 `protobuf:"fixed64,1,opt,name=percent_above_max,json=percentAboveMax" json:"percent_above_max,omitempty"` + PercentBelowMin *float64 `protobuf:"fixed64,2,opt,name=percent_below_min,json=percentBelowMin" json:"percent_below_min,omitempty"` + ValueOutsideThreshold *float64 `protobuf:"fixed64,3,opt,name=value_outside_threshold,json=valueOutsideThreshold" json:"value_outside_threshold,omitempty"` + MetricLabel *string `protobuf:"bytes,4,opt,name=metric_label,json=metricLabel" json:"metric_label,omitempty"` + Config *ThresholdConfig `protobuf:"bytes,5,opt,name=config" json:"config,omitempty"` + Regression *bool `protobuf:"varint,6,opt,name=regression" json:"regression,omitempty"` + CrossRunConfigExercised *bool `protobuf:"varint,7,opt,name=cross_run_config_exercised,json=crossRunConfigExercised,def=0" json:"cross_run_config_exercised,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ThresholdConfigResult) Reset() { *m = ThresholdConfigResult{} } +func (m *ThresholdConfigResult) String() string { return proto.CompactTextString(m) } +func (*ThresholdConfigResult) ProtoMessage() {} +func (*ThresholdConfigResult) Descriptor() ([]byte, []int) { + return fileDescriptor_efc166777e6a25c0, []int{4} +} + +func (m *ThresholdConfigResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ThresholdConfigResult.Unmarshal(m, b) +} +func (m *ThresholdConfigResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ThresholdConfigResult.Marshal(b, m, deterministic) +} +func (m *ThresholdConfigResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_ThresholdConfigResult.Merge(m, src) +} +func (m *ThresholdConfigResult) XXX_Size() int { + return xxx_messageInfo_ThresholdConfigResult.Size(m) +} +func (m *ThresholdConfigResult) XXX_DiscardUnknown() { + xxx_messageInfo_ThresholdConfigResult.DiscardUnknown(m) +} + +var xxx_messageInfo_ThresholdConfigResult proto.InternalMessageInfo + +const Default_ThresholdConfigResult_CrossRunConfigExercised bool = false + +func (m *ThresholdConfigResult) GetPercentAboveMax() float64 { + if m != nil && m.PercentAboveMax != nil { + return *m.PercentAboveMax + } + return 0 +} + +func (m *ThresholdConfigResult) GetPercentBelowMin() float64 { + if m != nil && m.PercentBelowMin != nil { + return *m.PercentBelowMin + } + return 0 +} + +func (m *ThresholdConfigResult) GetValueOutsideThreshold() float64 { + if m != nil && m.ValueOutsideThreshold != nil { + return *m.ValueOutsideThreshold + } + return 0 +} + +func (m *ThresholdConfigResult) GetMetricLabel() string { + if m != nil && m.MetricLabel != nil { + return *m.MetricLabel + } + return "" +} + +func (m *ThresholdConfigResult) GetConfig() *ThresholdConfig { + if m != nil { + return m.Config + } + return nil +} + +func (m *ThresholdConfigResult) GetRegression() bool { + if m != nil && m.Regression != nil { + return *m.Regression + } + return false +} + +func (m *ThresholdConfigResult) GetCrossRunConfigExercised() bool { + if m != nil && m.CrossRunConfigExercised != nil { + return *m.CrossRunConfigExercised + } + return Default_ThresholdConfigResult_CrossRunConfigExercised +} + +func init() { + proto.RegisterType((*ThresholdConfig)(nil), "mako.analyzers.threshold_analyzer.ThresholdConfig") + proto.RegisterType((*CrossRunConfig)(nil), "mako.analyzers.threshold_analyzer.CrossRunConfig") + proto.RegisterType((*ThresholdAnalyzerInput)(nil), "mako.analyzers.threshold_analyzer.ThresholdAnalyzerInput") + proto.RegisterType((*ThresholdAnalyzerOutput)(nil), "mako.analyzers.threshold_analyzer.ThresholdAnalyzerOutput") + proto.RegisterType((*ThresholdConfigResult)(nil), "mako.analyzers.threshold_analyzer.ThresholdConfigResult") +} + +func init() { + proto.RegisterFile("clients/proto/analyzers/threshold_analyzer.proto", fileDescriptor_efc166777e6a25c0) +} + +var fileDescriptor_efc166777e6a25c0 = []byte{ + // 654 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0xcf, 0x4e, 0x1b, 0x31, + 0x10, 0xc6, 0xb5, 0x09, 0xe1, 0xcf, 0x04, 0x42, 0x30, 0x4a, 0x59, 0x71, 0x68, 0x43, 0x4e, 0x51, + 0x0f, 0x4b, 0xe1, 0x50, 0x55, 0xbd, 0x01, 0x6d, 0x25, 0x10, 0x94, 0xd6, 0xe2, 0xd6, 0x83, 0xe5, + 0xec, 0x3a, 0xc1, 0xaa, 0xd7, 0x4e, 0x6d, 0x2f, 0x5d, 0x2a, 0xf5, 0x19, 0x2a, 0xf5, 0x6d, 0xfa, + 0x6a, 0x3d, 0x55, 0xf6, 0x7a, 0x43, 0x02, 0x95, 0x5a, 0x71, 0xb3, 0xbf, 0xf9, 0x69, 0x3c, 0xfe, + 0x66, 0x06, 0x5e, 0xa4, 0x82, 0x33, 0x69, 0xcd, 0xfe, 0x54, 0x2b, 0xab, 0xf6, 0xa9, 0xa4, 0xe2, + 0xf6, 0x1b, 0xd3, 0x66, 0xdf, 0x5e, 0x6b, 0x66, 0xae, 0x95, 0xc8, 0x48, 0xad, 0x25, 0x1e, 0x41, + 0x7b, 0x39, 0xfd, 0xac, 0x92, 0x19, 0x98, 0x3c, 0x04, 0x77, 0x7b, 0x66, 0xca, 0xd2, 0x90, 0xd1, + 0xd3, 0xfe, 0x38, 0xf8, 0x15, 0xc1, 0xe6, 0x55, 0x4d, 0x9f, 0x28, 0x39, 0xe6, 0x13, 0xd4, 0x85, + 0x66, 0xce, 0x65, 0x1c, 0xf5, 0xa3, 0x61, 0x84, 0xdd, 0xd1, 0x2b, 0xb4, 0x8c, 0x1b, 0x41, 0xa1, + 0x25, 0x4a, 0x60, 0x5b, 0x15, 0x56, 0x70, 0xa6, 0xc9, 0x94, 0xe9, 0x94, 0x49, 0x4b, 0x1c, 0xd1, + 0xf4, 0xc4, 0x56, 0x08, 0x7d, 0xa8, 0x22, 0x17, 0xb4, 0x44, 0x07, 0xd0, 0xce, 0xa8, 0xa5, 0x64, + 0xcc, 0x85, 0x65, 0x3a, 0x5e, 0xea, 0x47, 0xc3, 0xf6, 0x61, 0x37, 0xf1, 0x95, 0xbc, 0xa1, 0x96, + 0xbe, 0xf3, 0x3a, 0x86, 0x6c, 0x76, 0x46, 0xcf, 0xa0, 0x9d, 0xfa, 0x82, 0x88, 0xa4, 0x39, 0x8b, + 0x5b, 0xfd, 0x68, 0xb8, 0x86, 0xa1, 0x92, 0xde, 0xd3, 0x9c, 0x0d, 0xbe, 0x43, 0xe7, 0x44, 0x2b, + 0x63, 0x70, 0x21, 0x43, 0xe5, 0x47, 0xb0, 0xad, 0x0b, 0x49, 0xb8, 0x1c, 0x2b, 0xf2, 0xa5, 0x60, + 0xfa, 0x96, 0x08, 0x6e, 0x6c, 0x1c, 0xf5, 0x9b, 0xc3, 0xf6, 0x21, 0xaa, 0x5e, 0xc3, 0x85, 0x3c, + 0x95, 0x63, 0xf5, 0xd1, 0x85, 0x71, 0x57, 0xcf, 0xdd, 0xce, 0xb9, 0xb1, 0x68, 0x00, 0x1b, 0x39, + 0x97, 0xc4, 0xa5, 0x49, 0x55, 0x21, 0xad, 0xff, 0x52, 0x0b, 0xb7, 0x73, 0x2e, 0xfd, 0x3b, 0x85, + 0xb4, 0x67, 0x4b, 0xab, 0x8d, 0x6e, 0x73, 0xf0, 0xa3, 0x01, 0x4f, 0x66, 0xd6, 0x1d, 0x05, 0x9f, + 0x4f, 0xe5, 0xb4, 0xb0, 0xe8, 0x1c, 0x56, 0xaa, 0x3a, 0x4d, 0x78, 0xfb, 0x30, 0xf9, 0x67, 0x87, + 0x92, 0x7b, 0x6d, 0xc0, 0x75, 0x0a, 0x84, 0x60, 0xc9, 0x3b, 0xd0, 0xf0, 0x0e, 0xf8, 0x33, 0x7a, + 0x09, 0x3b, 0xd7, 0xdc, 0x58, 0xa5, 0x79, 0x4a, 0x05, 0x49, 0x95, 0xb4, 0xac, 0xb4, 0xc4, 0xd2, + 0x89, 0x89, 0x9b, 0xfd, 0xe6, 0x70, 0x0d, 0xf7, 0xee, 0xc2, 0x27, 0x55, 0xf4, 0x8a, 0x4e, 0x0c, + 0xfa, 0x04, 0xdd, 0xd4, 0x79, 0x16, 0x3e, 0xe8, 0x1e, 0x08, 0xcd, 0x38, 0xf8, 0x8f, 0x12, 0x17, + 0xed, 0xc6, 0x9d, 0x74, 0xe1, 0x3e, 0xf8, 0xd9, 0x80, 0x9d, 0x07, 0x8e, 0x5c, 0x16, 0xd6, 0x59, + 0x42, 0xa0, 0x13, 0xba, 0xa9, 0x99, 0x29, 0x84, 0xad, 0x9d, 0x79, 0xf5, 0x08, 0x67, 0x7c, 0x02, + 0xbc, 0x91, 0xce, 0xdd, 0x0c, 0x1a, 0x42, 0xd7, 0x35, 0xce, 0xf2, 0x9c, 0x19, 0x4b, 0xf3, 0x29, + 0xc9, 0x4d, 0x18, 0xd8, 0x4e, 0xce, 0xe5, 0x55, 0x2d, 0x5f, 0x54, 0x24, 0x2d, 0x17, 0xc9, 0x66, + 0x20, 0x69, 0x39, 0x4f, 0xf6, 0x61, 0xdd, 0xe5, 0x1c, 0x15, 0x5c, 0x64, 0x84, 0x67, 0xde, 0xa9, + 0x08, 0x43, 0xce, 0xe5, 0xb1, 0x93, 0x4e, 0x33, 0x4f, 0xd0, 0xf2, 0x8e, 0x68, 0x05, 0x82, 0x96, + 0x81, 0x18, 0xfc, 0x6e, 0x40, 0xef, 0xaf, 0x1f, 0x40, 0xcf, 0x61, 0xab, 0xde, 0x1d, 0x3a, 0x52, + 0x37, 0xcc, 0x6f, 0x50, 0xb5, 0x75, 0x9b, 0x21, 0x70, 0xe4, 0x74, 0xb7, 0x3f, 0x73, 0xec, 0x88, + 0x09, 0xf5, 0x95, 0xb8, 0x0d, 0x6d, 0x2c, 0xb0, 0xc7, 0x4e, 0xbf, 0xe0, 0xd2, 0xcd, 0xc6, 0x0d, + 0x15, 0x05, 0x23, 0xaa, 0xb0, 0x86, 0x67, 0x8c, 0xcc, 0x2c, 0x0d, 0xdf, 0xec, 0xf9, 0xf0, 0x65, + 0x15, 0x9d, 0xd5, 0x86, 0xf6, 0x60, 0x3d, 0x67, 0x56, 0xf3, 0x94, 0x08, 0x3a, 0x62, 0xc2, 0xff, + 0x76, 0x0d, 0xb7, 0x2b, 0xed, 0xdc, 0x49, 0xe8, 0x0c, 0x96, 0xc3, 0xd0, 0xb4, 0xfc, 0xd0, 0x3c, + 0x66, 0xae, 0x43, 0x06, 0xf4, 0x14, 0x40, 0xb3, 0x89, 0x66, 0xc6, 0x70, 0x25, 0xe3, 0xe5, 0x7e, + 0x34, 0x5c, 0xc5, 0x73, 0x0a, 0x3a, 0x86, 0xdd, 0xfb, 0xa3, 0x4a, 0x58, 0xc9, 0x74, 0xca, 0x0d, + 0xcb, 0xe2, 0x15, 0xc7, 0xbf, 0x6e, 0x8d, 0xa9, 0x30, 0x0c, 0xef, 0x2c, 0x0e, 0xe2, 0xdb, 0x9a, + 0xfa, 0x13, 0x00, 0x00, 0xff, 0xff, 0xda, 0x96, 0x85, 0xd7, 0x4b, 0x05, 0x00, 0x00, +} diff --git a/vendor/github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto/utest_analyzer.pb.go b/vendor/github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto/utest_analyzer.pb.go new file mode 100755 index 000000000..4c8d437dd --- /dev/null +++ b/vendor/github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto/utest_analyzer.pb.go @@ -0,0 +1,495 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: clients/proto/analyzers/utest_analyzer.proto + +package mako_utest_analyzer + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + mako_go_proto "github.com/google/mako/spec/proto/mako_go_proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type UTestConfig_DirectionBias int32 + +const ( + UTestConfig_NO_BIAS UTestConfig_DirectionBias = 0 + UTestConfig_IGNORE_INCREASE UTestConfig_DirectionBias = 1 + UTestConfig_IGNORE_DECREASE UTestConfig_DirectionBias = 2 +) + +var UTestConfig_DirectionBias_name = map[int32]string{ + 0: "NO_BIAS", + 1: "IGNORE_INCREASE", + 2: "IGNORE_DECREASE", +} + +var UTestConfig_DirectionBias_value = map[string]int32{ + "NO_BIAS": 0, + "IGNORE_INCREASE": 1, + "IGNORE_DECREASE": 2, +} + +func (x UTestConfig_DirectionBias) Enum() *UTestConfig_DirectionBias { + p := new(UTestConfig_DirectionBias) + *p = x + return p +} + +func (x UTestConfig_DirectionBias) String() string { + return proto.EnumName(UTestConfig_DirectionBias_name, int32(x)) +} + +func (x *UTestConfig_DirectionBias) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(UTestConfig_DirectionBias_value, data, "UTestConfig_DirectionBias") + if err != nil { + return err + } + *x = UTestConfig_DirectionBias(value) + return nil +} + +func (UTestConfig_DirectionBias) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{1, 0} +} + +type UTestAnalyzerInput struct { + ASample *UTestSample `protobuf:"bytes,1,opt,name=a_sample,json=aSample" json:"a_sample,omitempty"` + BSample *UTestSample `protobuf:"bytes,2,opt,name=b_sample,json=bSample" json:"b_sample,omitempty"` + ConfigList []*UTestConfig `protobuf:"bytes,3,rep,name=config_list,json=configList" json:"config_list,omitempty"` + Name *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UTestAnalyzerInput) Reset() { *m = UTestAnalyzerInput{} } +func (m *UTestAnalyzerInput) String() string { return proto.CompactTextString(m) } +func (*UTestAnalyzerInput) ProtoMessage() {} +func (*UTestAnalyzerInput) Descriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{0} +} + +func (m *UTestAnalyzerInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UTestAnalyzerInput.Unmarshal(m, b) +} +func (m *UTestAnalyzerInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UTestAnalyzerInput.Marshal(b, m, deterministic) +} +func (m *UTestAnalyzerInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_UTestAnalyzerInput.Merge(m, src) +} +func (m *UTestAnalyzerInput) XXX_Size() int { + return xxx_messageInfo_UTestAnalyzerInput.Size(m) +} +func (m *UTestAnalyzerInput) XXX_DiscardUnknown() { + xxx_messageInfo_UTestAnalyzerInput.DiscardUnknown(m) +} + +var xxx_messageInfo_UTestAnalyzerInput proto.InternalMessageInfo + +func (m *UTestAnalyzerInput) GetASample() *UTestSample { + if m != nil { + return m.ASample + } + return nil +} + +func (m *UTestAnalyzerInput) GetBSample() *UTestSample { + if m != nil { + return m.BSample + } + return nil +} + +func (m *UTestAnalyzerInput) GetConfigList() []*UTestConfig { + if m != nil { + return m.ConfigList + } + return nil +} + +func (m *UTestAnalyzerInput) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type UTestConfig struct { + AMetricKey *string `protobuf:"bytes,1,opt,name=a_metric_key,json=aMetricKey" json:"a_metric_key,omitempty"` + ADataFilter *mako_go_proto.DataFilter `protobuf:"bytes,8,opt,name=a_data_filter,json=aDataFilter" json:"a_data_filter,omitempty"` + BMetricKey *string `protobuf:"bytes,2,opt,name=b_metric_key,json=bMetricKey" json:"b_metric_key,omitempty"` + BDataFilter *mako_go_proto.DataFilter `protobuf:"bytes,9,opt,name=b_data_filter,json=bDataFilter" json:"b_data_filter,omitempty"` + ShiftValue *float64 `protobuf:"fixed64,3,opt,name=shift_value,json=shiftValue" json:"shift_value,omitempty"` + RelativeShiftValue *float64 `protobuf:"fixed64,7,opt,name=relative_shift_value,json=relativeShiftValue" json:"relative_shift_value,omitempty"` + DirectionBias *UTestConfig_DirectionBias `protobuf:"varint,4,opt,name=direction_bias,json=directionBias,enum=mako.utest_analyzer.UTestConfig_DirectionBias,def=0" json:"direction_bias,omitempty"` + SignificanceLevel *float64 `protobuf:"fixed64,5,opt,name=significance_level,json=significanceLevel" json:"significance_level,omitempty"` + ConfigName *string `protobuf:"bytes,6,opt,name=config_name,json=configName" json:"config_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UTestConfig) Reset() { *m = UTestConfig{} } +func (m *UTestConfig) String() string { return proto.CompactTextString(m) } +func (*UTestConfig) ProtoMessage() {} +func (*UTestConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{1} +} + +func (m *UTestConfig) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UTestConfig.Unmarshal(m, b) +} +func (m *UTestConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UTestConfig.Marshal(b, m, deterministic) +} +func (m *UTestConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_UTestConfig.Merge(m, src) +} +func (m *UTestConfig) XXX_Size() int { + return xxx_messageInfo_UTestConfig.Size(m) +} +func (m *UTestConfig) XXX_DiscardUnknown() { + xxx_messageInfo_UTestConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_UTestConfig proto.InternalMessageInfo + +const Default_UTestConfig_DirectionBias UTestConfig_DirectionBias = UTestConfig_NO_BIAS + +func (m *UTestConfig) GetAMetricKey() string { + if m != nil && m.AMetricKey != nil { + return *m.AMetricKey + } + return "" +} + +func (m *UTestConfig) GetADataFilter() *mako_go_proto.DataFilter { + if m != nil { + return m.ADataFilter + } + return nil +} + +func (m *UTestConfig) GetBMetricKey() string { + if m != nil && m.BMetricKey != nil { + return *m.BMetricKey + } + return "" +} + +func (m *UTestConfig) GetBDataFilter() *mako_go_proto.DataFilter { + if m != nil { + return m.BDataFilter + } + return nil +} + +func (m *UTestConfig) GetShiftValue() float64 { + if m != nil && m.ShiftValue != nil { + return *m.ShiftValue + } + return 0 +} + +func (m *UTestConfig) GetRelativeShiftValue() float64 { + if m != nil && m.RelativeShiftValue != nil { + return *m.RelativeShiftValue + } + return 0 +} + +func (m *UTestConfig) GetDirectionBias() UTestConfig_DirectionBias { + if m != nil && m.DirectionBias != nil { + return *m.DirectionBias + } + return Default_UTestConfig_DirectionBias +} + +func (m *UTestConfig) GetSignificanceLevel() float64 { + if m != nil && m.SignificanceLevel != nil { + return *m.SignificanceLevel + } + return 0 +} + +func (m *UTestConfig) GetConfigName() string { + if m != nil && m.ConfigName != nil { + return *m.ConfigName + } + return "" +} + +type UTestSample struct { + RunQueryList []*mako_go_proto.RunInfoQuery `protobuf:"bytes,1,rep,name=run_query_list,json=runQueryList" json:"run_query_list,omitempty"` + IncludeCurrentRun *bool `protobuf:"varint,2,opt,name=include_current_run,json=includeCurrentRun,def=0" json:"include_current_run,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UTestSample) Reset() { *m = UTestSample{} } +func (m *UTestSample) String() string { return proto.CompactTextString(m) } +func (*UTestSample) ProtoMessage() {} +func (*UTestSample) Descriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{2} +} + +func (m *UTestSample) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UTestSample.Unmarshal(m, b) +} +func (m *UTestSample) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UTestSample.Marshal(b, m, deterministic) +} +func (m *UTestSample) XXX_Merge(src proto.Message) { + xxx_messageInfo_UTestSample.Merge(m, src) +} +func (m *UTestSample) XXX_Size() int { + return xxx_messageInfo_UTestSample.Size(m) +} +func (m *UTestSample) XXX_DiscardUnknown() { + xxx_messageInfo_UTestSample.DiscardUnknown(m) +} + +var xxx_messageInfo_UTestSample proto.InternalMessageInfo + +const Default_UTestSample_IncludeCurrentRun bool = false + +func (m *UTestSample) GetRunQueryList() []*mako_go_proto.RunInfoQuery { + if m != nil { + return m.RunQueryList + } + return nil +} + +func (m *UTestSample) GetIncludeCurrentRun() bool { + if m != nil && m.IncludeCurrentRun != nil { + return *m.IncludeCurrentRun + } + return Default_UTestSample_IncludeCurrentRun +} + +type UTestAnalyzerOutput struct { + Summary *string `protobuf:"bytes,1,opt,name=summary" json:"summary,omitempty"` + ConfigResultList []*UTestConfigResult `protobuf:"bytes,2,rep,name=config_result_list,json=configResultList" json:"config_result_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UTestAnalyzerOutput) Reset() { *m = UTestAnalyzerOutput{} } +func (m *UTestAnalyzerOutput) String() string { return proto.CompactTextString(m) } +func (*UTestAnalyzerOutput) ProtoMessage() {} +func (*UTestAnalyzerOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{3} +} + +func (m *UTestAnalyzerOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UTestAnalyzerOutput.Unmarshal(m, b) +} +func (m *UTestAnalyzerOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UTestAnalyzerOutput.Marshal(b, m, deterministic) +} +func (m *UTestAnalyzerOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_UTestAnalyzerOutput.Merge(m, src) +} +func (m *UTestAnalyzerOutput) XXX_Size() int { + return xxx_messageInfo_UTestAnalyzerOutput.Size(m) +} +func (m *UTestAnalyzerOutput) XXX_DiscardUnknown() { + xxx_messageInfo_UTestAnalyzerOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_UTestAnalyzerOutput proto.InternalMessageInfo + +func (m *UTestAnalyzerOutput) GetSummary() string { + if m != nil && m.Summary != nil { + return *m.Summary + } + return "" +} + +func (m *UTestAnalyzerOutput) GetConfigResultList() []*UTestConfigResult { + if m != nil { + return m.ConfigResultList + } + return nil +} + +type UTestConfigResult struct { + Config *UTestConfig `protobuf:"bytes,5,opt,name=config" json:"config,omitempty"` + AMetricLabel *string `protobuf:"bytes,6,opt,name=a_metric_label,json=aMetricLabel" json:"a_metric_label,omitempty"` + BMetricLabel *string `protobuf:"bytes,7,opt,name=b_metric_label,json=bMetricLabel" json:"b_metric_label,omitempty"` + AMedian *float64 `protobuf:"fixed64,8,opt,name=a_median,json=aMedian" json:"a_median,omitempty"` + BMedian *float64 `protobuf:"fixed64,9,opt,name=b_median,json=bMedian" json:"b_median,omitempty"` + ZStatistic *float64 `protobuf:"fixed64,1,opt,name=z_statistic,json=zStatistic" json:"z_statistic,omitempty"` + PValue *float64 `protobuf:"fixed64,2,opt,name=p_value,json=pValue" json:"p_value,omitempty"` + RegressionFound *bool `protobuf:"varint,3,opt,name=regression_found,json=regressionFound" json:"regression_found,omitempty"` + ConfigName *string `protobuf:"bytes,4,opt,name=config_name,json=configName" json:"config_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UTestConfigResult) Reset() { *m = UTestConfigResult{} } +func (m *UTestConfigResult) String() string { return proto.CompactTextString(m) } +func (*UTestConfigResult) ProtoMessage() {} +func (*UTestConfigResult) Descriptor() ([]byte, []int) { + return fileDescriptor_e2b697cdbf0773fa, []int{4} +} + +func (m *UTestConfigResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UTestConfigResult.Unmarshal(m, b) +} +func (m *UTestConfigResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UTestConfigResult.Marshal(b, m, deterministic) +} +func (m *UTestConfigResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_UTestConfigResult.Merge(m, src) +} +func (m *UTestConfigResult) XXX_Size() int { + return xxx_messageInfo_UTestConfigResult.Size(m) +} +func (m *UTestConfigResult) XXX_DiscardUnknown() { + xxx_messageInfo_UTestConfigResult.DiscardUnknown(m) +} + +var xxx_messageInfo_UTestConfigResult proto.InternalMessageInfo + +func (m *UTestConfigResult) GetConfig() *UTestConfig { + if m != nil { + return m.Config + } + return nil +} + +func (m *UTestConfigResult) GetAMetricLabel() string { + if m != nil && m.AMetricLabel != nil { + return *m.AMetricLabel + } + return "" +} + +func (m *UTestConfigResult) GetBMetricLabel() string { + if m != nil && m.BMetricLabel != nil { + return *m.BMetricLabel + } + return "" +} + +func (m *UTestConfigResult) GetAMedian() float64 { + if m != nil && m.AMedian != nil { + return *m.AMedian + } + return 0 +} + +func (m *UTestConfigResult) GetBMedian() float64 { + if m != nil && m.BMedian != nil { + return *m.BMedian + } + return 0 +} + +func (m *UTestConfigResult) GetZStatistic() float64 { + if m != nil && m.ZStatistic != nil { + return *m.ZStatistic + } + return 0 +} + +func (m *UTestConfigResult) GetPValue() float64 { + if m != nil && m.PValue != nil { + return *m.PValue + } + return 0 +} + +func (m *UTestConfigResult) GetRegressionFound() bool { + if m != nil && m.RegressionFound != nil { + return *m.RegressionFound + } + return false +} + +func (m *UTestConfigResult) GetConfigName() string { + if m != nil && m.ConfigName != nil { + return *m.ConfigName + } + return "" +} + +func init() { + proto.RegisterEnum("mako.utest_analyzer.UTestConfig_DirectionBias", UTestConfig_DirectionBias_name, UTestConfig_DirectionBias_value) + proto.RegisterType((*UTestAnalyzerInput)(nil), "mako.utest_analyzer.UTestAnalyzerInput") + proto.RegisterType((*UTestConfig)(nil), "mako.utest_analyzer.UTestConfig") + proto.RegisterType((*UTestSample)(nil), "mako.utest_analyzer.UTestSample") + proto.RegisterType((*UTestAnalyzerOutput)(nil), "mako.utest_analyzer.UTestAnalyzerOutput") + proto.RegisterType((*UTestConfigResult)(nil), "mako.utest_analyzer.UTestConfigResult") +} + +func init() { + proto.RegisterFile("clients/proto/analyzers/utest_analyzer.proto", fileDescriptor_e2b697cdbf0773fa) +} + +var fileDescriptor_e2b697cdbf0773fa = []byte{ + // 728 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdd, 0x4e, 0xdb, 0x30, + 0x14, 0x5e, 0x4a, 0xa1, 0xed, 0x29, 0x94, 0xe2, 0x6e, 0x5a, 0xb7, 0x1b, 0xaa, 0x6a, 0x9a, 0x98, + 0xb4, 0x85, 0x09, 0x0d, 0x09, 0xb1, 0xab, 0x16, 0xca, 0x54, 0x01, 0x65, 0x73, 0xd9, 0x2e, 0x67, + 0x39, 0xa9, 0xd3, 0x59, 0x24, 0x4e, 0x67, 0x3b, 0x48, 0xe5, 0x62, 0x77, 0x93, 0xf6, 0x82, 0x7b, + 0x84, 0xbd, 0xc7, 0x64, 0x27, 0x81, 0x94, 0xfd, 0xc0, 0x9d, 0xfd, 0xfd, 0x9c, 0x38, 0xc7, 0xe7, + 0x33, 0xbc, 0xf4, 0x43, 0xce, 0x84, 0x56, 0xdb, 0x33, 0x19, 0xeb, 0x78, 0x9b, 0x0a, 0x1a, 0xce, + 0xaf, 0x98, 0x54, 0xdb, 0x89, 0x66, 0x4a, 0x93, 0x7c, 0xef, 0x5a, 0x1a, 0xb5, 0x22, 0x7a, 0x11, + 0xbb, 0x8b, 0xd4, 0xd3, 0x47, 0x6a, 0xc6, 0xfc, 0xcc, 0x6f, 0x79, 0xbb, 0xec, 0xfe, 0x72, 0x00, + 0x7d, 0x3c, 0x67, 0x4a, 0xf7, 0x32, 0xe1, 0x50, 0xcc, 0x12, 0x8d, 0xde, 0x42, 0x95, 0x12, 0x45, + 0xa3, 0x59, 0xc8, 0xda, 0x4e, 0xc7, 0xd9, 0xaa, 0xef, 0x74, 0xdc, 0xbf, 0x54, 0x75, 0xad, 0x75, + 0x6c, 0x75, 0xb8, 0x42, 0xd3, 0x85, 0x31, 0x7b, 0xb9, 0xb9, 0x74, 0x5f, 0xb3, 0x97, 0x99, 0x7b, + 0x50, 0xf7, 0x63, 0x11, 0xf0, 0x29, 0x09, 0xb9, 0xd2, 0xed, 0xa5, 0xce, 0xd2, 0xff, 0xfd, 0x07, + 0x56, 0x8c, 0x21, 0x35, 0x9d, 0x70, 0xa5, 0x11, 0x82, 0xb2, 0xa0, 0x11, 0x6b, 0x97, 0x3b, 0xce, + 0x56, 0x0d, 0xdb, 0x75, 0xf7, 0x47, 0x19, 0xea, 0x05, 0x3d, 0xea, 0xc0, 0x2a, 0x25, 0x11, 0xd3, + 0x92, 0xfb, 0xe4, 0x82, 0xcd, 0xed, 0x4f, 0xd6, 0x30, 0xd0, 0x53, 0x0b, 0x1d, 0xb3, 0x39, 0x7a, + 0x03, 0x6b, 0x94, 0x4c, 0xa8, 0xa6, 0x24, 0xe0, 0xa1, 0x66, 0xb2, 0x5d, 0xb5, 0xbf, 0xd2, 0x4c, + 0x8f, 0x72, 0x48, 0x35, 0x3d, 0xb2, 0x38, 0xae, 0xd3, 0x9b, 0x8d, 0xa9, 0xeb, 0x15, 0xeb, 0x96, + 0xd2, 0xba, 0xde, 0x42, 0x5d, 0x6f, 0xa1, 0x6e, 0xed, 0x5f, 0x75, 0xbd, 0x42, 0xdd, 0x4d, 0xa8, + 0xab, 0x2f, 0x3c, 0xd0, 0xe4, 0x92, 0x86, 0x09, 0x6b, 0x2f, 0x75, 0x9c, 0x2d, 0x07, 0x83, 0x85, + 0x3e, 0x19, 0x04, 0xbd, 0x86, 0x87, 0x92, 0x85, 0x54, 0xf3, 0x4b, 0x46, 0x8a, 0xca, 0x8a, 0x55, + 0xa2, 0x9c, 0x1b, 0xdf, 0x38, 0x3e, 0x43, 0x63, 0xc2, 0x25, 0xf3, 0x35, 0x8f, 0x05, 0xf1, 0x38, + 0x55, 0xb6, 0x61, 0x8d, 0x1d, 0xf7, 0xae, 0x66, 0xbb, 0x87, 0xb9, 0xad, 0xcf, 0xa9, 0xda, 0xaf, + 0x8c, 0xce, 0x48, 0x7f, 0xd8, 0x1b, 0xe3, 0xb5, 0x49, 0x11, 0x47, 0xaf, 0x00, 0x29, 0x3e, 0x15, + 0x3c, 0xe0, 0x3e, 0x15, 0x3e, 0x23, 0x21, 0xbb, 0x64, 0x61, 0x7b, 0xd9, 0x9e, 0x67, 0xa3, 0xc8, + 0x9c, 0x18, 0xc2, 0xfc, 0x61, 0x76, 0xf1, 0xf6, 0xf2, 0x56, 0xd2, 0xc6, 0xa5, 0xd0, 0xc8, 0x5c, + 0xe1, 0x11, 0xac, 0x2d, 0x7c, 0x18, 0xd5, 0x21, 0xff, 0x74, 0xf3, 0x01, 0x6a, 0xc1, 0xfa, 0xf0, + 0xdd, 0xe8, 0x0c, 0x0f, 0xc8, 0x70, 0x74, 0x80, 0x07, 0xbd, 0xf1, 0xa0, 0xe9, 0x14, 0xc0, 0xc3, + 0x41, 0x06, 0x96, 0xba, 0xdf, 0xb2, 0x49, 0xc8, 0x06, 0x6e, 0x0f, 0x1a, 0x32, 0x11, 0xe4, 0x6b, + 0xc2, 0xe4, 0x3c, 0x9d, 0x39, 0xc7, 0xce, 0x1c, 0x4a, 0xdb, 0x80, 0x13, 0x31, 0x14, 0x41, 0xfc, + 0xc1, 0xd0, 0x78, 0x55, 0x26, 0xc2, 0xae, 0xec, 0x9c, 0xed, 0x42, 0x8b, 0x0b, 0x3f, 0x4c, 0x26, + 0x8c, 0xf8, 0x89, 0x94, 0x4c, 0x68, 0x22, 0x13, 0x61, 0xaf, 0xbc, 0xba, 0xbf, 0x1c, 0xd0, 0x50, + 0x31, 0xbc, 0x91, 0x29, 0x0e, 0x52, 0x01, 0x4e, 0x44, 0xf7, 0xbb, 0x03, 0xad, 0x85, 0xc8, 0x9d, + 0x25, 0xda, 0x64, 0xae, 0x0d, 0x15, 0x95, 0x44, 0x11, 0x95, 0xf9, 0x34, 0xe6, 0x5b, 0x74, 0x0e, + 0x28, 0x6b, 0x8d, 0x64, 0x2a, 0x09, 0x75, 0x7a, 0xcc, 0x92, 0x3d, 0xe6, 0xf3, 0x3b, 0xa3, 0x61, + 0x2d, 0xb8, 0xe9, 0x17, 0x76, 0xe6, 0xf8, 0xdd, 0x9f, 0x25, 0xd8, 0xf8, 0x43, 0x87, 0xf6, 0x60, + 0x25, 0x55, 0xda, 0x9b, 0xba, 0x4f, 0xf4, 0x32, 0x3d, 0x7a, 0x06, 0x8d, 0xeb, 0x48, 0x85, 0xd4, + 0x63, 0x61, 0x76, 0x87, 0xab, 0x59, 0xa8, 0x4e, 0x0c, 0x66, 0x54, 0xde, 0xa2, 0xaa, 0x92, 0xaa, + 0xbc, 0xa2, 0xea, 0x89, 0x79, 0x7f, 0x22, 0x36, 0xe1, 0x54, 0xd8, 0xdc, 0x39, 0xb8, 0x42, 0x4f, + 0xed, 0xd6, 0x50, 0x5e, 0x4e, 0xd5, 0x52, 0xca, 0xcb, 0xa8, 0x4d, 0xa8, 0x5f, 0x11, 0xa5, 0xa9, + 0xe6, 0x4a, 0x73, 0xdf, 0x76, 0xd1, 0xc1, 0x70, 0x35, 0xce, 0x11, 0xf4, 0x18, 0x2a, 0xb3, 0x2c, + 0x17, 0x25, 0x4b, 0xae, 0xcc, 0xd2, 0x2c, 0xbc, 0x80, 0xa6, 0x64, 0x53, 0xc9, 0x94, 0x32, 0x61, + 0x08, 0xe2, 0x44, 0x4c, 0x6c, 0xc6, 0xaa, 0x78, 0xfd, 0x06, 0x3f, 0x32, 0xf0, 0xed, 0x39, 0x2d, + 0xdf, 0x9e, 0xd3, 0xfe, 0x31, 0xec, 0xfa, 0x71, 0xe4, 0x4e, 0xe3, 0x78, 0x1a, 0x32, 0xd7, 0xf4, + 0x8d, 0x8b, 0xa9, 0x3b, 0x63, 0x32, 0x88, 0x65, 0x64, 0xe6, 0x3d, 0xed, 0x68, 0xf6, 0xa4, 0xbb, + 0xd7, 0x8f, 0x79, 0x7f, 0xf1, 0x21, 0x7e, 0x6f, 0xde, 0xe7, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0xf0, 0xc0, 0xec, 0x97, 0xfa, 0x05, 0x00, 0x00, +} diff --git a/vendor/github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto/window_deviation.pb.go b/vendor/github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto/window_deviation.pb.go new file mode 100755 index 000000000..5fe8856b5 --- /dev/null +++ b/vendor/github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto/window_deviation.pb.go @@ -0,0 +1,855 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: clients/proto/analyzers/window_deviation.proto + +package mako_window_deviation + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + mako_go_proto "github.com/google/mako/spec/proto/mako_go_proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type ToleranceCheck_DirectionBias int32 + +const ( + ToleranceCheck_NO_BIAS ToleranceCheck_DirectionBias = 0 + ToleranceCheck_IGNORE_INCREASE ToleranceCheck_DirectionBias = 1 + ToleranceCheck_IGNORE_DECREASE ToleranceCheck_DirectionBias = 2 +) + +var ToleranceCheck_DirectionBias_name = map[int32]string{ + 0: "NO_BIAS", + 1: "IGNORE_INCREASE", + 2: "IGNORE_DECREASE", +} + +var ToleranceCheck_DirectionBias_value = map[string]int32{ + "NO_BIAS": 0, + "IGNORE_INCREASE": 1, + "IGNORE_DECREASE": 2, +} + +func (x ToleranceCheck_DirectionBias) Enum() *ToleranceCheck_DirectionBias { + p := new(ToleranceCheck_DirectionBias) + *p = x + return p +} + +func (x ToleranceCheck_DirectionBias) String() string { + return proto.EnumName(ToleranceCheck_DirectionBias_name, int32(x)) +} + +func (x *ToleranceCheck_DirectionBias) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ToleranceCheck_DirectionBias_value, data, "ToleranceCheck_DirectionBias") + if err != nil { + return err + } + *x = ToleranceCheck_DirectionBias(value) + return nil +} + +func (ToleranceCheck_DirectionBias) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{1, 0} +} + +type WindowDeviationOutput_ToleranceCheckOutput_CheckResult int32 + +const ( + WindowDeviationOutput_ToleranceCheckOutput_UNDEFINED WindowDeviationOutput_ToleranceCheckOutput_CheckResult = 0 + WindowDeviationOutput_ToleranceCheckOutput_REGRESSED WindowDeviationOutput_ToleranceCheckOutput_CheckResult = 1 + WindowDeviationOutput_ToleranceCheckOutput_SKIPPED WindowDeviationOutput_ToleranceCheckOutput_CheckResult = 2 + WindowDeviationOutput_ToleranceCheckOutput_PASSED WindowDeviationOutput_ToleranceCheckOutput_CheckResult = 3 +) + +var WindowDeviationOutput_ToleranceCheckOutput_CheckResult_name = map[int32]string{ + 0: "UNDEFINED", + 1: "REGRESSED", + 2: "SKIPPED", + 3: "PASSED", +} + +var WindowDeviationOutput_ToleranceCheckOutput_CheckResult_value = map[string]int32{ + "UNDEFINED": 0, + "REGRESSED": 1, + "SKIPPED": 2, + "PASSED": 3, +} + +func (x WindowDeviationOutput_ToleranceCheckOutput_CheckResult) Enum() *WindowDeviationOutput_ToleranceCheckOutput_CheckResult { + p := new(WindowDeviationOutput_ToleranceCheckOutput_CheckResult) + *p = x + return p +} + +func (x WindowDeviationOutput_ToleranceCheckOutput_CheckResult) String() string { + return proto.EnumName(WindowDeviationOutput_ToleranceCheckOutput_CheckResult_name, int32(x)) +} + +func (x *WindowDeviationOutput_ToleranceCheckOutput_CheckResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(WindowDeviationOutput_ToleranceCheckOutput_CheckResult_value, data, "WindowDeviationOutput_ToleranceCheckOutput_CheckResult") + if err != nil { + return err + } + *x = WindowDeviationOutput_ToleranceCheckOutput_CheckResult(value) + return nil +} + +func (WindowDeviationOutput_ToleranceCheckOutput_CheckResult) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{4, 0, 0} +} + +type WindowDeviationInput struct { + RunInfoQueryList []*mako_go_proto.RunInfoQuery `protobuf:"bytes,1,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"` + ToleranceCheckList []*ToleranceCheck `protobuf:"bytes,2,rep,name=tolerance_check_list,json=toleranceCheckList" json:"tolerance_check_list,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WindowDeviationInput) Reset() { *m = WindowDeviationInput{} } +func (m *WindowDeviationInput) String() string { return proto.CompactTextString(m) } +func (*WindowDeviationInput) ProtoMessage() {} +func (*WindowDeviationInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{0} +} + +func (m *WindowDeviationInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WindowDeviationInput.Unmarshal(m, b) +} +func (m *WindowDeviationInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WindowDeviationInput.Marshal(b, m, deterministic) +} +func (m *WindowDeviationInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_WindowDeviationInput.Merge(m, src) +} +func (m *WindowDeviationInput) XXX_Size() int { + return xxx_messageInfo_WindowDeviationInput.Size(m) +} +func (m *WindowDeviationInput) XXX_DiscardUnknown() { + xxx_messageInfo_WindowDeviationInput.DiscardUnknown(m) +} + +var xxx_messageInfo_WindowDeviationInput proto.InternalMessageInfo + +func (m *WindowDeviationInput) GetRunInfoQueryList() []*mako_go_proto.RunInfoQuery { + if m != nil { + return m.RunInfoQueryList + } + return nil +} + +func (m *WindowDeviationInput) GetToleranceCheckList() []*ToleranceCheck { + if m != nil { + return m.ToleranceCheckList + } + return nil +} + +func (m *WindowDeviationInput) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type ToleranceCheck struct { + DataFilter *mako_go_proto.DataFilter `protobuf:"bytes,1,opt,name=data_filter,json=dataFilter" json:"data_filter,omitempty"` + RecentWindowSize *int32 `protobuf:"varint,2,opt,name=recent_window_size,json=recentWindowSize,def=1" json:"recent_window_size,omitempty"` + MinimumHistoricalWindowSize *int32 `protobuf:"varint,6,opt,name=minimum_historical_window_size,json=minimumHistoricalWindowSize,def=3" json:"minimum_historical_window_size,omitempty"` + DirectionBias *ToleranceCheck_DirectionBias `protobuf:"varint,3,opt,name=direction_bias,json=directionBias,enum=mako.window_deviation.ToleranceCheck_DirectionBias,def=0" json:"direction_bias,omitempty"` + MeanToleranceParamsList []*MeanToleranceParams `protobuf:"bytes,4,rep,name=mean_tolerance_params_list,json=meanToleranceParamsList" json:"mean_tolerance_params_list,omitempty"` + MedianToleranceParamsList []*MedianToleranceParams `protobuf:"bytes,5,rep,name=median_tolerance_params_list,json=medianToleranceParamsList" json:"median_tolerance_params_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ToleranceCheck) Reset() { *m = ToleranceCheck{} } +func (m *ToleranceCheck) String() string { return proto.CompactTextString(m) } +func (*ToleranceCheck) ProtoMessage() {} +func (*ToleranceCheck) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{1} +} + +func (m *ToleranceCheck) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ToleranceCheck.Unmarshal(m, b) +} +func (m *ToleranceCheck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ToleranceCheck.Marshal(b, m, deterministic) +} +func (m *ToleranceCheck) XXX_Merge(src proto.Message) { + xxx_messageInfo_ToleranceCheck.Merge(m, src) +} +func (m *ToleranceCheck) XXX_Size() int { + return xxx_messageInfo_ToleranceCheck.Size(m) +} +func (m *ToleranceCheck) XXX_DiscardUnknown() { + xxx_messageInfo_ToleranceCheck.DiscardUnknown(m) +} + +var xxx_messageInfo_ToleranceCheck proto.InternalMessageInfo + +const Default_ToleranceCheck_RecentWindowSize int32 = 1 +const Default_ToleranceCheck_MinimumHistoricalWindowSize int32 = 3 +const Default_ToleranceCheck_DirectionBias ToleranceCheck_DirectionBias = ToleranceCheck_NO_BIAS + +func (m *ToleranceCheck) GetDataFilter() *mako_go_proto.DataFilter { + if m != nil { + return m.DataFilter + } + return nil +} + +func (m *ToleranceCheck) GetRecentWindowSize() int32 { + if m != nil && m.RecentWindowSize != nil { + return *m.RecentWindowSize + } + return Default_ToleranceCheck_RecentWindowSize +} + +func (m *ToleranceCheck) GetMinimumHistoricalWindowSize() int32 { + if m != nil && m.MinimumHistoricalWindowSize != nil { + return *m.MinimumHistoricalWindowSize + } + return Default_ToleranceCheck_MinimumHistoricalWindowSize +} + +func (m *ToleranceCheck) GetDirectionBias() ToleranceCheck_DirectionBias { + if m != nil && m.DirectionBias != nil { + return *m.DirectionBias + } + return Default_ToleranceCheck_DirectionBias +} + +func (m *ToleranceCheck) GetMeanToleranceParamsList() []*MeanToleranceParams { + if m != nil { + return m.MeanToleranceParamsList + } + return nil +} + +func (m *ToleranceCheck) GetMedianToleranceParamsList() []*MedianToleranceParams { + if m != nil { + return m.MedianToleranceParamsList + } + return nil +} + +type MeanToleranceParams struct { + ConstTerm *float64 `protobuf:"fixed64,1,opt,name=const_term,json=constTerm,def=0" json:"const_term,omitempty"` + MeanCoeff *float64 `protobuf:"fixed64,2,opt,name=mean_coeff,json=meanCoeff,def=0" json:"mean_coeff,omitempty"` + StddevCoeff *float64 `protobuf:"fixed64,3,opt,name=stddev_coeff,json=stddevCoeff,def=0" json:"stddev_coeff,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MeanToleranceParams) Reset() { *m = MeanToleranceParams{} } +func (m *MeanToleranceParams) String() string { return proto.CompactTextString(m) } +func (*MeanToleranceParams) ProtoMessage() {} +func (*MeanToleranceParams) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{2} +} + +func (m *MeanToleranceParams) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MeanToleranceParams.Unmarshal(m, b) +} +func (m *MeanToleranceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MeanToleranceParams.Marshal(b, m, deterministic) +} +func (m *MeanToleranceParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeanToleranceParams.Merge(m, src) +} +func (m *MeanToleranceParams) XXX_Size() int { + return xxx_messageInfo_MeanToleranceParams.Size(m) +} +func (m *MeanToleranceParams) XXX_DiscardUnknown() { + xxx_messageInfo_MeanToleranceParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MeanToleranceParams proto.InternalMessageInfo + +const Default_MeanToleranceParams_ConstTerm float64 = 0 +const Default_MeanToleranceParams_MeanCoeff float64 = 0 +const Default_MeanToleranceParams_StddevCoeff float64 = 0 + +func (m *MeanToleranceParams) GetConstTerm() float64 { + if m != nil && m.ConstTerm != nil { + return *m.ConstTerm + } + return Default_MeanToleranceParams_ConstTerm +} + +func (m *MeanToleranceParams) GetMeanCoeff() float64 { + if m != nil && m.MeanCoeff != nil { + return *m.MeanCoeff + } + return Default_MeanToleranceParams_MeanCoeff +} + +func (m *MeanToleranceParams) GetStddevCoeff() float64 { + if m != nil && m.StddevCoeff != nil { + return *m.StddevCoeff + } + return Default_MeanToleranceParams_StddevCoeff +} + +type MedianToleranceParams struct { + ConstTerm *float64 `protobuf:"fixed64,1,opt,name=const_term,json=constTerm,def=0" json:"const_term,omitempty"` + MedianCoeff *float64 `protobuf:"fixed64,2,opt,name=median_coeff,json=medianCoeff,def=0" json:"median_coeff,omitempty"` + MadCoeff *float64 `protobuf:"fixed64,3,opt,name=mad_coeff,json=madCoeff,def=0" json:"mad_coeff,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MedianToleranceParams) Reset() { *m = MedianToleranceParams{} } +func (m *MedianToleranceParams) String() string { return proto.CompactTextString(m) } +func (*MedianToleranceParams) ProtoMessage() {} +func (*MedianToleranceParams) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{3} +} + +func (m *MedianToleranceParams) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MedianToleranceParams.Unmarshal(m, b) +} +func (m *MedianToleranceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MedianToleranceParams.Marshal(b, m, deterministic) +} +func (m *MedianToleranceParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MedianToleranceParams.Merge(m, src) +} +func (m *MedianToleranceParams) XXX_Size() int { + return xxx_messageInfo_MedianToleranceParams.Size(m) +} +func (m *MedianToleranceParams) XXX_DiscardUnknown() { + xxx_messageInfo_MedianToleranceParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MedianToleranceParams proto.InternalMessageInfo + +const Default_MedianToleranceParams_ConstTerm float64 = 0 +const Default_MedianToleranceParams_MedianCoeff float64 = 0 +const Default_MedianToleranceParams_MadCoeff float64 = 0 + +func (m *MedianToleranceParams) GetConstTerm() float64 { + if m != nil && m.ConstTerm != nil { + return *m.ConstTerm + } + return Default_MedianToleranceParams_ConstTerm +} + +func (m *MedianToleranceParams) GetMedianCoeff() float64 { + if m != nil && m.MedianCoeff != nil { + return *m.MedianCoeff + } + return Default_MedianToleranceParams_MedianCoeff +} + +func (m *MedianToleranceParams) GetMadCoeff() float64 { + if m != nil && m.MadCoeff != nil { + return *m.MadCoeff + } + return Default_MedianToleranceParams_MadCoeff +} + +type WindowDeviationOutput struct { + OutputMessage *string `protobuf:"bytes,1,opt,name=output_message,json=outputMessage" json:"output_message,omitempty"` + Checks []*WindowDeviationOutput_ToleranceCheckOutput `protobuf:"bytes,3,rep,name=checks" json:"checks,omitempty"` + ChecksSkippedForMissingData []*ToleranceCheck `protobuf:"bytes,2,rep,name=checks_skipped_for_missing_data,json=checksSkippedForMissingData" json:"checks_skipped_for_missing_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WindowDeviationOutput) Reset() { *m = WindowDeviationOutput{} } +func (m *WindowDeviationOutput) String() string { return proto.CompactTextString(m) } +func (*WindowDeviationOutput) ProtoMessage() {} +func (*WindowDeviationOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{4} +} + +func (m *WindowDeviationOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WindowDeviationOutput.Unmarshal(m, b) +} +func (m *WindowDeviationOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WindowDeviationOutput.Marshal(b, m, deterministic) +} +func (m *WindowDeviationOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_WindowDeviationOutput.Merge(m, src) +} +func (m *WindowDeviationOutput) XXX_Size() int { + return xxx_messageInfo_WindowDeviationOutput.Size(m) +} +func (m *WindowDeviationOutput) XXX_DiscardUnknown() { + xxx_messageInfo_WindowDeviationOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_WindowDeviationOutput proto.InternalMessageInfo + +func (m *WindowDeviationOutput) GetOutputMessage() string { + if m != nil && m.OutputMessage != nil { + return *m.OutputMessage + } + return "" +} + +func (m *WindowDeviationOutput) GetChecks() []*WindowDeviationOutput_ToleranceCheckOutput { + if m != nil { + return m.Checks + } + return nil +} + +func (m *WindowDeviationOutput) GetChecksSkippedForMissingData() []*ToleranceCheck { + if m != nil { + return m.ChecksSkippedForMissingData + } + return nil +} + +type WindowDeviationOutput_ToleranceCheckOutput struct { + ToleranceCheck *ToleranceCheck `protobuf:"bytes,1,opt,name=tolerance_check,json=toleranceCheck" json:"tolerance_check,omitempty"` + Result *WindowDeviationOutput_ToleranceCheckOutput_CheckResult `protobuf:"varint,2,opt,name=result,enum=mako.window_deviation.WindowDeviationOutput_ToleranceCheckOutput_CheckResult,def=0" json:"result,omitempty"` + MetricLabel *string `protobuf:"bytes,3,opt,name=metric_label,json=metricLabel" json:"metric_label,omitempty"` + Stats *ToleranceCheckStats `protobuf:"bytes,4,opt,name=stats" json:"stats,omitempty"` + HistoricalWindowMinTimestampMs *float64 `protobuf:"fixed64,5,opt,name=historical_window_min_timestamp_ms,json=historicalWindowMinTimestampMs" json:"historical_window_min_timestamp_ms,omitempty"` + HistoricalWindowMaxTimestampMs *float64 `protobuf:"fixed64,6,opt,name=historical_window_max_timestamp_ms,json=historicalWindowMaxTimestampMs" json:"historical_window_max_timestamp_ms,omitempty"` + HistoricalWindowMinBuildId *float64 `protobuf:"fixed64,7,opt,name=historical_window_min_build_id,json=historicalWindowMinBuildId" json:"historical_window_min_build_id,omitempty"` + HistoricalWindowMaxBuildId *float64 `protobuf:"fixed64,8,opt,name=historical_window_max_build_id,json=historicalWindowMaxBuildId" json:"historical_window_max_build_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) Reset() { + *m = WindowDeviationOutput_ToleranceCheckOutput{} +} +func (m *WindowDeviationOutput_ToleranceCheckOutput) String() string { + return proto.CompactTextString(m) +} +func (*WindowDeviationOutput_ToleranceCheckOutput) ProtoMessage() {} +func (*WindowDeviationOutput_ToleranceCheckOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{4, 0} +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput.Unmarshal(m, b) +} +func (m *WindowDeviationOutput_ToleranceCheckOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput.Marshal(b, m, deterministic) +} +func (m *WindowDeviationOutput_ToleranceCheckOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput.Merge(m, src) +} +func (m *WindowDeviationOutput_ToleranceCheckOutput) XXX_Size() int { + return xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput.Size(m) +} +func (m *WindowDeviationOutput_ToleranceCheckOutput) XXX_DiscardUnknown() { + xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_WindowDeviationOutput_ToleranceCheckOutput proto.InternalMessageInfo + +const Default_WindowDeviationOutput_ToleranceCheckOutput_Result WindowDeviationOutput_ToleranceCheckOutput_CheckResult = WindowDeviationOutput_ToleranceCheckOutput_UNDEFINED + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetToleranceCheck() *ToleranceCheck { + if m != nil { + return m.ToleranceCheck + } + return nil +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetResult() WindowDeviationOutput_ToleranceCheckOutput_CheckResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_WindowDeviationOutput_ToleranceCheckOutput_Result +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetMetricLabel() string { + if m != nil && m.MetricLabel != nil { + return *m.MetricLabel + } + return "" +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetStats() *ToleranceCheckStats { + if m != nil { + return m.Stats + } + return nil +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetHistoricalWindowMinTimestampMs() float64 { + if m != nil && m.HistoricalWindowMinTimestampMs != nil { + return *m.HistoricalWindowMinTimestampMs + } + return 0 +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetHistoricalWindowMaxTimestampMs() float64 { + if m != nil && m.HistoricalWindowMaxTimestampMs != nil { + return *m.HistoricalWindowMaxTimestampMs + } + return 0 +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetHistoricalWindowMinBuildId() float64 { + if m != nil && m.HistoricalWindowMinBuildId != nil { + return *m.HistoricalWindowMinBuildId + } + return 0 +} + +func (m *WindowDeviationOutput_ToleranceCheckOutput) GetHistoricalWindowMaxBuildId() float64 { + if m != nil && m.HistoricalWindowMaxBuildId != nil { + return *m.HistoricalWindowMaxBuildId + } + return 0 +} + +type ToleranceCheckStats struct { + HistoricDataLength *int32 `protobuf:"varint,1,opt,name=historic_data_length,json=historicDataLength" json:"historic_data_length,omitempty"` + RecentDataLength *int32 `protobuf:"varint,2,opt,name=recent_data_length,json=recentDataLength" json:"recent_data_length,omitempty"` + HistoricMean *float64 `protobuf:"fixed64,3,opt,name=historic_mean,json=historicMean" json:"historic_mean,omitempty"` + HistoricMedian *float64 `protobuf:"fixed64,4,opt,name=historic_median,json=historicMedian" json:"historic_median,omitempty"` + HistoricStddev *float64 `protobuf:"fixed64,5,opt,name=historic_stddev,json=historicStddev" json:"historic_stddev,omitempty"` + HistoricMad *float64 `protobuf:"fixed64,6,opt,name=historic_mad,json=historicMad" json:"historic_mad,omitempty"` + RecentMean *float64 `protobuf:"fixed64,7,opt,name=recent_mean,json=recentMean" json:"recent_mean,omitempty"` + RecentMedian *float64 `protobuf:"fixed64,8,opt,name=recent_median,json=recentMedian" json:"recent_median,omitempty"` + DeltaMean *float64 `protobuf:"fixed64,9,opt,name=delta_mean,json=deltaMean" json:"delta_mean,omitempty"` + DeltaMedian *float64 `protobuf:"fixed64,10,opt,name=delta_median,json=deltaMedian" json:"delta_median,omitempty"` + MeanToleranceCheckResult []*MeanToleranceCheckResult `protobuf:"bytes,11,rep,name=mean_tolerance_check_result,json=meanToleranceCheckResult" json:"mean_tolerance_check_result,omitempty"` + MedianToleranceCheckResult []*MedianToleranceCheckResult `protobuf:"bytes,12,rep,name=median_tolerance_check_result,json=medianToleranceCheckResult" json:"median_tolerance_check_result,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ToleranceCheckStats) Reset() { *m = ToleranceCheckStats{} } +func (m *ToleranceCheckStats) String() string { return proto.CompactTextString(m) } +func (*ToleranceCheckStats) ProtoMessage() {} +func (*ToleranceCheckStats) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{5} +} + +func (m *ToleranceCheckStats) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ToleranceCheckStats.Unmarshal(m, b) +} +func (m *ToleranceCheckStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ToleranceCheckStats.Marshal(b, m, deterministic) +} +func (m *ToleranceCheckStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_ToleranceCheckStats.Merge(m, src) +} +func (m *ToleranceCheckStats) XXX_Size() int { + return xxx_messageInfo_ToleranceCheckStats.Size(m) +} +func (m *ToleranceCheckStats) XXX_DiscardUnknown() { + xxx_messageInfo_ToleranceCheckStats.DiscardUnknown(m) +} + +var xxx_messageInfo_ToleranceCheckStats proto.InternalMessageInfo + +func (m *ToleranceCheckStats) GetHistoricDataLength() int32 { + if m != nil && m.HistoricDataLength != nil { + return *m.HistoricDataLength + } + return 0 +} + +func (m *ToleranceCheckStats) GetRecentDataLength() int32 { + if m != nil && m.RecentDataLength != nil { + return *m.RecentDataLength + } + return 0 +} + +func (m *ToleranceCheckStats) GetHistoricMean() float64 { + if m != nil && m.HistoricMean != nil { + return *m.HistoricMean + } + return 0 +} + +func (m *ToleranceCheckStats) GetHistoricMedian() float64 { + if m != nil && m.HistoricMedian != nil { + return *m.HistoricMedian + } + return 0 +} + +func (m *ToleranceCheckStats) GetHistoricStddev() float64 { + if m != nil && m.HistoricStddev != nil { + return *m.HistoricStddev + } + return 0 +} + +func (m *ToleranceCheckStats) GetHistoricMad() float64 { + if m != nil && m.HistoricMad != nil { + return *m.HistoricMad + } + return 0 +} + +func (m *ToleranceCheckStats) GetRecentMean() float64 { + if m != nil && m.RecentMean != nil { + return *m.RecentMean + } + return 0 +} + +func (m *ToleranceCheckStats) GetRecentMedian() float64 { + if m != nil && m.RecentMedian != nil { + return *m.RecentMedian + } + return 0 +} + +func (m *ToleranceCheckStats) GetDeltaMean() float64 { + if m != nil && m.DeltaMean != nil { + return *m.DeltaMean + } + return 0 +} + +func (m *ToleranceCheckStats) GetDeltaMedian() float64 { + if m != nil && m.DeltaMedian != nil { + return *m.DeltaMedian + } + return 0 +} + +func (m *ToleranceCheckStats) GetMeanToleranceCheckResult() []*MeanToleranceCheckResult { + if m != nil { + return m.MeanToleranceCheckResult + } + return nil +} + +func (m *ToleranceCheckStats) GetMedianToleranceCheckResult() []*MedianToleranceCheckResult { + if m != nil { + return m.MedianToleranceCheckResult + } + return nil +} + +type MeanToleranceCheckResult struct { + Params *MeanToleranceParams `protobuf:"bytes,1,opt,name=params" json:"params,omitempty"` + Tolerance *float64 `protobuf:"fixed64,2,opt,name=tolerance" json:"tolerance,omitempty"` + IsRegressed *bool `protobuf:"varint,3,opt,name=is_regressed,json=isRegressed" json:"is_regressed,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MeanToleranceCheckResult) Reset() { *m = MeanToleranceCheckResult{} } +func (m *MeanToleranceCheckResult) String() string { return proto.CompactTextString(m) } +func (*MeanToleranceCheckResult) ProtoMessage() {} +func (*MeanToleranceCheckResult) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{6} +} + +func (m *MeanToleranceCheckResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MeanToleranceCheckResult.Unmarshal(m, b) +} +func (m *MeanToleranceCheckResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MeanToleranceCheckResult.Marshal(b, m, deterministic) +} +func (m *MeanToleranceCheckResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MeanToleranceCheckResult.Merge(m, src) +} +func (m *MeanToleranceCheckResult) XXX_Size() int { + return xxx_messageInfo_MeanToleranceCheckResult.Size(m) +} +func (m *MeanToleranceCheckResult) XXX_DiscardUnknown() { + xxx_messageInfo_MeanToleranceCheckResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MeanToleranceCheckResult proto.InternalMessageInfo + +func (m *MeanToleranceCheckResult) GetParams() *MeanToleranceParams { + if m != nil { + return m.Params + } + return nil +} + +func (m *MeanToleranceCheckResult) GetTolerance() float64 { + if m != nil && m.Tolerance != nil { + return *m.Tolerance + } + return 0 +} + +func (m *MeanToleranceCheckResult) GetIsRegressed() bool { + if m != nil && m.IsRegressed != nil { + return *m.IsRegressed + } + return false +} + +type MedianToleranceCheckResult struct { + Params *MedianToleranceParams `protobuf:"bytes,1,opt,name=params" json:"params,omitempty"` + Tolerance *float64 `protobuf:"fixed64,2,opt,name=tolerance" json:"tolerance,omitempty"` + IsRegressed *bool `protobuf:"varint,3,opt,name=is_regressed,json=isRegressed" json:"is_regressed,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MedianToleranceCheckResult) Reset() { *m = MedianToleranceCheckResult{} } +func (m *MedianToleranceCheckResult) String() string { return proto.CompactTextString(m) } +func (*MedianToleranceCheckResult) ProtoMessage() {} +func (*MedianToleranceCheckResult) Descriptor() ([]byte, []int) { + return fileDescriptor_b20e6734acd2d200, []int{7} +} + +func (m *MedianToleranceCheckResult) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MedianToleranceCheckResult.Unmarshal(m, b) +} +func (m *MedianToleranceCheckResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MedianToleranceCheckResult.Marshal(b, m, deterministic) +} +func (m *MedianToleranceCheckResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_MedianToleranceCheckResult.Merge(m, src) +} +func (m *MedianToleranceCheckResult) XXX_Size() int { + return xxx_messageInfo_MedianToleranceCheckResult.Size(m) +} +func (m *MedianToleranceCheckResult) XXX_DiscardUnknown() { + xxx_messageInfo_MedianToleranceCheckResult.DiscardUnknown(m) +} + +var xxx_messageInfo_MedianToleranceCheckResult proto.InternalMessageInfo + +func (m *MedianToleranceCheckResult) GetParams() *MedianToleranceParams { + if m != nil { + return m.Params + } + return nil +} + +func (m *MedianToleranceCheckResult) GetTolerance() float64 { + if m != nil && m.Tolerance != nil { + return *m.Tolerance + } + return 0 +} + +func (m *MedianToleranceCheckResult) GetIsRegressed() bool { + if m != nil && m.IsRegressed != nil { + return *m.IsRegressed + } + return false +} + +func init() { + proto.RegisterEnum("mako.window_deviation.ToleranceCheck_DirectionBias", ToleranceCheck_DirectionBias_name, ToleranceCheck_DirectionBias_value) + proto.RegisterEnum("mako.window_deviation.WindowDeviationOutput_ToleranceCheckOutput_CheckResult", WindowDeviationOutput_ToleranceCheckOutput_CheckResult_name, WindowDeviationOutput_ToleranceCheckOutput_CheckResult_value) + proto.RegisterType((*WindowDeviationInput)(nil), "mako.window_deviation.WindowDeviationInput") + proto.RegisterType((*ToleranceCheck)(nil), "mako.window_deviation.ToleranceCheck") + proto.RegisterType((*MeanToleranceParams)(nil), "mako.window_deviation.MeanToleranceParams") + proto.RegisterType((*MedianToleranceParams)(nil), "mako.window_deviation.MedianToleranceParams") + proto.RegisterType((*WindowDeviationOutput)(nil), "mako.window_deviation.WindowDeviationOutput") + proto.RegisterType((*WindowDeviationOutput_ToleranceCheckOutput)(nil), "mako.window_deviation.WindowDeviationOutput.ToleranceCheckOutput") + proto.RegisterType((*ToleranceCheckStats)(nil), "mako.window_deviation.ToleranceCheckStats") + proto.RegisterType((*MeanToleranceCheckResult)(nil), "mako.window_deviation.MeanToleranceCheckResult") + proto.RegisterType((*MedianToleranceCheckResult)(nil), "mako.window_deviation.MedianToleranceCheckResult") +} + +func init() { + proto.RegisterFile("clients/proto/analyzers/window_deviation.proto", fileDescriptor_b20e6734acd2d200) +} + +var fileDescriptor_b20e6734acd2d200 = []byte{ + // 1160 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0xdb, 0x36, + 0x14, 0xae, 0x92, 0xd8, 0xad, 0x9f, 0x6c, 0xd7, 0x60, 0x12, 0xcc, 0x73, 0xdb, 0x34, 0x75, 0x5b, + 0x2c, 0x28, 0x0a, 0xa5, 0x4d, 0xb1, 0x4b, 0x4e, 0x8b, 0x6b, 0xa7, 0xf3, 0x56, 0xbb, 0x19, 0xdd, + 0xa1, 0xd8, 0x89, 0x60, 0x25, 0xda, 0x21, 0x22, 0x4a, 0x9e, 0x48, 0xb7, 0x69, 0x2f, 0xfd, 0x53, + 0x76, 0xe8, 0x75, 0xff, 0xc4, 0x2e, 0xfb, 0xaf, 0x06, 0x0c, 0x24, 0x25, 0xff, 0x8a, 0x05, 0x38, + 0xd8, 0x6e, 0xf2, 0xc7, 0xef, 0x7d, 0xef, 0x23, 0xdf, 0xd3, 0xa3, 0x0c, 0x9e, 0x1f, 0x72, 0x16, + 0x29, 0x79, 0x38, 0x4e, 0x62, 0x15, 0x1f, 0xd2, 0x88, 0x86, 0x9f, 0x3e, 0xb3, 0x44, 0x1e, 0x7e, + 0xe4, 0x51, 0x10, 0x7f, 0x24, 0x01, 0xfb, 0xc0, 0xa9, 0xe2, 0x71, 0xe4, 0x19, 0x02, 0xda, 0x15, + 0xf4, 0x22, 0xf6, 0x96, 0x17, 0x1b, 0xbb, 0x72, 0xcc, 0xfc, 0x54, 0xc3, 0x30, 0xcc, 0x63, 0xf3, + 0x6f, 0x07, 0x76, 0xde, 0x19, 0x6e, 0x3b, 0xa3, 0x76, 0xa3, 0xf1, 0x44, 0xa1, 0x13, 0xd8, 0x4e, + 0x26, 0x11, 0xe1, 0xd1, 0x30, 0x26, 0xbf, 0x4f, 0x58, 0xf2, 0x89, 0x84, 0x5c, 0xaa, 0xba, 0xb3, + 0xbf, 0x79, 0xe0, 0x1e, 0x21, 0xcf, 0x48, 0xe0, 0x49, 0xd4, 0x8d, 0x86, 0xf1, 0x2f, 0x7a, 0x19, + 0xd7, 0x92, 0xb9, 0x5f, 0xaf, 0xb9, 0x54, 0xe8, 0x1d, 0xec, 0xa8, 0x38, 0x64, 0x09, 0x8d, 0x7c, + 0x46, 0xfc, 0x73, 0xe6, 0x5f, 0x58, 0x8d, 0x0d, 0xa3, 0xf1, 0xd8, 0x5b, 0x69, 0xd4, 0x7b, 0x9b, + 0x85, 0xbc, 0xd4, 0x11, 0x18, 0xa9, 0x85, 0xdf, 0x46, 0x18, 0xc1, 0x56, 0x44, 0x05, 0xab, 0x6f, + 0xee, 0x3b, 0x07, 0x25, 0x6c, 0x9e, 0x9b, 0x7f, 0x6d, 0x41, 0x75, 0x31, 0x14, 0x3d, 0x07, 0x37, + 0xa0, 0x8a, 0x92, 0x21, 0x0f, 0x15, 0x4b, 0xea, 0xce, 0xbe, 0x73, 0xe0, 0x1e, 0xd5, 0x6c, 0xda, + 0x36, 0x55, 0xf4, 0xd4, 0xe0, 0x18, 0x82, 0xe9, 0x33, 0x3a, 0x04, 0x94, 0x30, 0x9f, 0x45, 0x8a, + 0xa4, 0xbe, 0x24, 0xff, 0xcc, 0xea, 0x1b, 0xfb, 0xce, 0x41, 0xe1, 0xd8, 0x79, 0x8e, 0x6b, 0x76, + 0xd1, 0x1e, 0xd8, 0x80, 0x7f, 0x66, 0xe8, 0x14, 0xf6, 0x04, 0x8f, 0xb8, 0x98, 0x08, 0x72, 0xce, + 0xa5, 0x8a, 0x13, 0xee, 0xd3, 0x70, 0x21, 0xb8, 0x68, 0x83, 0x5f, 0xe0, 0x3b, 0x29, 0xf1, 0xc7, + 0x29, 0x6f, 0x4e, 0xc7, 0x87, 0x6a, 0xc0, 0x13, 0xe6, 0xeb, 0x23, 0x20, 0xef, 0x39, 0x95, 0x66, + 0x73, 0xd5, 0xa3, 0x17, 0x6b, 0x9d, 0x92, 0xd7, 0xce, 0x62, 0x5b, 0x9c, 0xca, 0xe3, 0x9b, 0xfd, + 0x37, 0xa4, 0xd5, 0x3d, 0x19, 0xe0, 0x4a, 0x30, 0x8f, 0xa3, 0x11, 0x34, 0x04, 0xa3, 0x11, 0x99, + 0x55, 0x65, 0x4c, 0x13, 0x2a, 0xa4, 0x2d, 0xcb, 0x96, 0x29, 0xcb, 0x93, 0x9c, 0x84, 0x3d, 0x46, + 0xa3, 0x69, 0xd2, 0x33, 0x13, 0x86, 0xbf, 0x11, 0x57, 0x41, 0x53, 0x20, 0x01, 0x77, 0x05, 0x0b, + 0x78, 0x6e, 0xaa, 0x82, 0x49, 0xf5, 0x34, 0x37, 0x95, 0x0e, 0x5d, 0x4e, 0xf6, 0xad, 0x58, 0x05, + 0xeb, 0x74, 0xcd, 0x53, 0xa8, 0x2c, 0x1c, 0x00, 0x72, 0x21, 0x3b, 0x82, 0xda, 0x0d, 0xb4, 0x0d, + 0xb7, 0xbb, 0xaf, 0xfa, 0x6f, 0x70, 0x87, 0x74, 0xfb, 0x2f, 0x71, 0xe7, 0x64, 0xd0, 0xa9, 0x39, + 0x73, 0x60, 0xbb, 0x93, 0x82, 0x1b, 0xcd, 0x2f, 0xb0, 0xbd, 0x62, 0x9b, 0x68, 0x1f, 0xc0, 0x8f, + 0x23, 0xa9, 0x88, 0x62, 0x89, 0x30, 0x6d, 0xe4, 0x1c, 0x3b, 0xcf, 0x70, 0xc9, 0x80, 0x6f, 0x59, + 0x22, 0x34, 0xc3, 0x1c, 0xac, 0x1f, 0xb3, 0xe1, 0xd0, 0xb4, 0x8b, 0x65, 0x68, 0xf0, 0xa5, 0xc6, + 0xd0, 0x23, 0x28, 0x4b, 0x15, 0x04, 0xec, 0x43, 0xca, 0xd9, 0xcc, 0x38, 0xae, 0x85, 0x0d, 0xab, + 0xf9, 0x05, 0x76, 0x57, 0x6e, 0x7e, 0x0d, 0x0b, 0x8f, 0xa0, 0x9c, 0x1e, 0xf9, 0x92, 0x09, 0xd7, + 0xc2, 0xd6, 0xc6, 0x1e, 0x94, 0x04, 0x0d, 0x96, 0x3d, 0xdc, 0x12, 0x34, 0xb0, 0x06, 0xfe, 0xbc, + 0x09, 0xbb, 0x4b, 0xe3, 0xe0, 0xcd, 0x44, 0xe9, 0x79, 0xf0, 0x18, 0xaa, 0xb1, 0x79, 0x22, 0x82, + 0x49, 0x49, 0x47, 0xcc, 0xb8, 0x28, 0xe1, 0x8a, 0x45, 0x7b, 0x16, 0x44, 0xbf, 0x41, 0xd1, 0xbc, + 0xe9, 0xba, 0x7f, 0x75, 0x8d, 0x4f, 0x72, 0x6a, 0xbc, 0x32, 0xc9, 0x52, 0x57, 0x5b, 0x10, 0xa7, + 0x82, 0xe8, 0x02, 0xee, 0xdb, 0x27, 0x22, 0x2f, 0xf8, 0x78, 0xcc, 0x02, 0x32, 0x8c, 0x13, 0x22, + 0xb8, 0x94, 0x3c, 0x1a, 0x11, 0xfd, 0x12, 0x5f, 0x6f, 0xb2, 0xdc, 0xb1, 0x6a, 0x03, 0x2b, 0x76, + 0x1a, 0x27, 0x3d, 0x2b, 0xa5, 0x47, 0x43, 0xe3, 0x6b, 0x01, 0x76, 0x56, 0xb9, 0x41, 0x7d, 0xb8, + 0xbd, 0x34, 0xd4, 0xd2, 0xc1, 0xb2, 0x66, 0xd6, 0xea, 0xe2, 0x3c, 0x43, 0x63, 0x28, 0x26, 0x4c, + 0x4e, 0x42, 0x65, 0x2a, 0x56, 0x3d, 0xea, 0xfd, 0xe7, 0x03, 0xf3, 0x6c, 0x22, 0x23, 0x7a, 0x5c, + 0xfa, 0xb5, 0xdf, 0xee, 0x9c, 0x76, 0xfb, 0x9d, 0x36, 0x4e, 0xf3, 0xa0, 0x07, 0xba, 0x53, 0x54, + 0xc2, 0x7d, 0x12, 0xd2, 0xf7, 0x2c, 0x4c, 0xa7, 0xa8, 0x6b, 0xb1, 0xd7, 0x1a, 0x42, 0x3f, 0x40, + 0x41, 0x2a, 0xaa, 0x64, 0x7d, 0xcb, 0x6c, 0xed, 0xc9, 0x5a, 0x5b, 0x1b, 0xe8, 0x08, 0x6c, 0x03, + 0xd1, 0x4f, 0xd0, 0xbc, 0x3a, 0x0f, 0x05, 0x8f, 0x88, 0xe2, 0x82, 0x49, 0x45, 0xc5, 0x98, 0x08, + 0x59, 0x2f, 0xe8, 0x0e, 0xc4, 0x7b, 0xe7, 0x4b, 0x13, 0xb1, 0xc7, 0xa3, 0xb7, 0x19, 0xad, 0x97, + 0xa7, 0x45, 0x2f, 0x17, 0xb5, 0x8a, 0x39, 0x5a, 0xf4, 0x72, 0x5e, 0xab, 0x05, 0x7b, 0xab, 0x7d, + 0xbd, 0x9f, 0xf0, 0x30, 0x20, 0x3c, 0xa8, 0xdf, 0x34, 0x3a, 0x8d, 0x15, 0x9e, 0x5a, 0x9a, 0xd2, + 0x0d, 0x72, 0x34, 0xe8, 0xe5, 0x4c, 0xe3, 0x56, 0x8e, 0x06, 0xbd, 0x4c, 0x35, 0x9a, 0x6d, 0x70, + 0xe7, 0xca, 0x84, 0x2a, 0x30, 0x2b, 0x54, 0xed, 0x86, 0xfe, 0x89, 0x3b, 0xaf, 0x70, 0x67, 0x30, + 0xe8, 0xb4, 0x6b, 0x8e, 0x1e, 0x67, 0x83, 0x9f, 0xbb, 0x67, 0x67, 0x9d, 0x76, 0x6d, 0x03, 0x01, + 0x14, 0xcf, 0x4e, 0xcc, 0xc2, 0x66, 0xf3, 0x9f, 0x2d, 0xd8, 0x5e, 0x51, 0x04, 0xf4, 0x0c, 0x76, + 0xb2, 0xdc, 0xe6, 0xc5, 0x20, 0x21, 0x8b, 0x46, 0xea, 0xdc, 0x74, 0x6a, 0x01, 0xa3, 0x6c, 0x4d, + 0x77, 0xfa, 0x6b, 0xb3, 0x82, 0x9e, 0x4e, 0x2f, 0xbe, 0x79, 0xbe, 0xb9, 0xf8, 0xb2, 0x5b, 0x6f, + 0x8e, 0xfd, 0x10, 0x2a, 0x53, 0x7d, 0x3d, 0xe3, 0xec, 0x28, 0xc1, 0xe5, 0x0c, 0xd4, 0x53, 0x14, + 0x7d, 0x07, 0xb7, 0xe7, 0x48, 0x7a, 0x06, 0x99, 0x76, 0x72, 0x70, 0x75, 0x46, 0xd3, 0xe8, 0x02, + 0xd1, 0x4e, 0xc3, 0xb4, 0x31, 0xa6, 0xc4, 0x81, 0x41, 0x75, 0xe7, 0xce, 0x14, 0x69, 0x90, 0x96, + 0xdc, 0x9d, 0xca, 0xd1, 0x00, 0xdd, 0x07, 0x37, 0xdd, 0x87, 0xf1, 0x65, 0x8b, 0x09, 0x16, 0x32, + 0xae, 0x1e, 0x42, 0x65, 0x4a, 0x30, 0x9e, 0x6c, 0xad, 0xca, 0x19, 0xc5, 0x38, 0xba, 0x07, 0x10, + 0xb0, 0x50, 0x51, 0x2b, 0x52, 0x32, 0x8c, 0x92, 0x41, 0x8c, 0xc6, 0x03, 0x28, 0x67, 0xcb, 0x46, + 0x02, 0xac, 0x8f, 0x94, 0x60, 0x14, 0x22, 0xb8, 0xb3, 0x74, 0xd5, 0xda, 0x0f, 0xa0, 0xf4, 0x5d, + 0x77, 0xcd, 0xa0, 0x3a, 0x5c, 0xe7, 0xae, 0x9d, 0x6b, 0x13, 0x5c, 0x17, 0x39, 0x2b, 0x48, 0xc1, + 0xbd, 0x2b, 0x37, 0xee, 0x42, 0xc6, 0xb2, 0xc9, 0xf8, 0x7c, 0xbd, 0x2b, 0x77, 0x3e, 0x67, 0x43, + 0xe4, 0xae, 0x35, 0xff, 0x70, 0xa0, 0x9e, 0x67, 0x16, 0xb5, 0xa0, 0x68, 0xef, 0xfc, 0x74, 0x40, + 0x5e, 0xe7, 0xcb, 0x22, 0x8d, 0x44, 0x77, 0xa1, 0x34, 0xdd, 0x8f, 0xbd, 0xd2, 0xf0, 0x0c, 0xd0, + 0x75, 0xe0, 0x92, 0x24, 0x6c, 0x94, 0x30, 0x29, 0x59, 0x60, 0xba, 0xf0, 0x16, 0x76, 0xb9, 0xc4, + 0x19, 0xd4, 0xfc, 0xea, 0x40, 0x23, 0x7f, 0x73, 0xa8, 0xbd, 0xe4, 0xf1, 0x7a, 0x9f, 0x24, 0xff, + 0x97, 0xcb, 0x56, 0x0f, 0xbe, 0xf7, 0x63, 0xe1, 0x8d, 0xe2, 0x78, 0x14, 0x32, 0x4f, 0x31, 0xa9, + 0x78, 0x34, 0xf2, 0xc6, 0x2c, 0x19, 0xc6, 0x89, 0xd0, 0x22, 0xd6, 0x56, 0xfa, 0x4f, 0xc0, 0x9b, + 0xfe, 0x07, 0x68, 0x2d, 0x7f, 0xbb, 0x9f, 0xe9, 0x8f, 0xfa, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, + 0x42, 0x5b, 0xd8, 0x0f, 0x33, 0x0c, 0x00, 0x00, +} diff --git a/vendor/github.com/google/mako/helpers/go/quickstore/quickstore.go b/vendor/github.com/google/mako/helpers/go/quickstore/quickstore.go new file mode 100644 index 000000000..fdc9e52ad --- /dev/null +++ b/vendor/github.com/google/mako/helpers/go/quickstore/quickstore.go @@ -0,0 +1,301 @@ +// Copyright 2019 Google LLC +// +// 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 +// +// https://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 quickstore offers a way to utilize Mako storage, downsampling, +// aggregation and analyzers in a simple way. This is most helpful when you have +// a pre-existing benchmarking tool which exports data that you would like to +// save in Mako. +// +// To use: Understand and create a Mako benchmark to hold your data. See +// go/mako-help?tmpl=storage#bench for more information about benchmarks. +// Watch 'Chart' videos at go/mako-videos for demos of the Mako +// dashboard. +// +// Basic usage: +// // Store data, metric and run aggregates will be calculated automatically. +// q := quickstore.Quickstore{BenchmarkKey: myBenchmarkKey} +// for _, data := range []float64{4, 6, 40, 3.2} { +// q.AddSamplePoint(timestampMs, data) +// output, err = q.Store() +// if err != nil { +// if output.GetStatus() == qpb.QuickstoreOutput_ANALYSIS_FAIL { +// // handle analysis failure +// } else { +// // handle error +// } +// } +// +// See more examples inside https://github.com/google/mako/blob/master/helpers/go/quickstore/quickstore_example_test.go +// +// Struct is not concurrent safe +// +// More information about quickstore: go/mako-quickstore +package quickstore + +import ( + "context" + "errors" + + "flag" + "os" + + log "github.com/golang/glog" + "github.com/golang/protobuf/proto" + "google.golang.org/grpc" + + qpb "github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto" + qspb "github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto" + pgpb "github.com/google/mako/spec/proto/mako_go_proto" + + _ "github.com/google/mako/internal/go/common" // b/111726961 +) + +// Quickstore allows saving of data passed via Add* methods to Mako. +// Zero struct is usable but before calling Store() you must populate: +// * BenchmarkKey to the Mako benchmark you'd like your data saved to. +// OR +// * Input (with Input.BenchmarkKey set) to define more information about the +// Mako run where you data will be stored. See QuickstoreInput for more +// information. +type Quickstore struct { + // BenchmarkKey to where your data will be stored to. + BenchmarkKey string + // Allows more information to be passed about the Mako Run that will be + // created. + Input qpb.QuickstoreInput + samplePoints []*pgpb.SamplePoint + sampleErrors []*pgpb.SampleError + runAggregates []*pgpb.KeyedValue + metricAggValueKeys []string + metricAggTypes []string + metricAggValues []float64 + saverImpl saver +} + +// NewAtAddress creates a new Quickstore that connects to a Quickstore microservice at the provided gRPC address. +// +// Along with the Quickstore instance, it returns a function that can be called to request +// the microsevice terminate itself. This function can be ignored in order to leave the microservice +// running. +func NewAtAddress(ctx context.Context, input *qpb.QuickstoreInput, address string) (*Quickstore, func(context.Context), error) { + conn, err := grpc.DialContext(ctx, address, grpc.WithInsecure(), grpc.WithBlock()) + if err != nil { + log.Fatalf("did not connect: %v", err) + } + + client := qspb.NewQuickstoreClient(conn) + return &Quickstore{ + Input: *input, + saverImpl: &grpcSaver{client}, + }, func(ctx context.Context) { + client.ShutdownMicroservice(ctx, &qspb.ShutdownInput{}) + }, nil +} + +// AddSamplePoint adds a sample at the specified x-value. +// +// How the x-value is interpreted depends on your benchmark configuration. See +// BenchmarkInfo.input_value_info for more information. +// +// The map represents a mapping from metric to value. +// It is more efficient for Mako to store multiple metrics collected at +// the same xval together, but it is optional. +// +// When adding data via this function, calling the Add*Aggregate() functions +// is optional, as the aggregates will get computed by this class. +// +// An error is returned if there was a problem adding data. +func (q *Quickstore) AddSamplePoint(xval float64, valueKeyToYVals map[string]float64) error { + s := pgpb.SamplePoint{InputValue: proto.Float64(xval)} + for valueKey, value := range valueKeyToYVals { + s.MetricValueList = append(s.MetricValueList, + &pgpb.KeyedValue{ + ValueKey: proto.String(valueKey), + Value: proto.Float64(value)}) + } + q.samplePoints = append(q.samplePoints, &s) + return nil +} + +// AddError add an error at the specified xval. +// +// When adding errors via this function, the aggregate error count will be set +// automatically. +// +// An error is returned if there was a problem adding data. +func (q *Quickstore) AddError(xval float64, errorMessage string) error { + q.sampleErrors = append(q.sampleErrors, &pgpb.SampleError{InputValue: proto.Float64(xval), + ErrorMessage: proto.String(errorMessage)}) + return nil +} + +// AddRunAggregate adds an aggregate value over the entire run. +// If value_key is: +// * "~ignore_sample_count" +// * "~usable_sample_count" +// * "~error_sample_count" +// * "~benchmark_score" +// The corresponding value will be overwritten inside +// https://github.com/google/mako/blob/master/spec/proto/mako.proto +// of these values are provided, they will be calculated automatically by the +// framework based on SamplePoints/Errors provided before Store() is called. +// +// Otherwise the value_key will be set to a custom aggregate (See +// https://github.com/google/mako/blob/master/spec/proto/mako.proto +// +// If no run aggregates are manully set with this method, values are +// automatically calculated. +// +// An error is returned if there was a problem adding data. +func (q *Quickstore) AddRunAggregate(valueKey string, value float64) error { + q.runAggregates = append(q.runAggregates, &pgpb.KeyedValue{ValueKey: proto.String(valueKey), + Value: proto.Float64(value)}) + return nil +} + +// AddMetricAggregate adds an aggregate for a specific metric. +// If value_key is: +// * "min" +// * "max" +// * "mean" +// * "median" +// * "standard_deviation" +// * "median_absolute_deviation" +// * "count" +// The corresponding value inside +// https://github.com/google/mako/blob/master/spec/proto/mako.proto +// be set. +// +// The value_key can also represent a percentile see +// https://github.com/google/mako/blob/master/spec/proto/mako.proto +// +// For example "p98000" would be interpreted as the 98th percentile. These +// need to correspond to the percentiles that your benchmark has set. +// It is an error to supply an percentile that is not part of your benchmark. +// If any percentiles are provided, the automatically calculated percentiles +// will be cleared to 0. +// +// If any aggregate_types (eg. "min") are set for a value_key it will +// overwrite the entire MetricAggregate for that value_key. If no +// aggregate_types are provided for a value_key metric aggregates (including +// percentiles) will be calculated automatically based on data provided via +// calls to AddSamplePoint. +// +// An error is returned if there was a problem adding data. +func (q *Quickstore) AddMetricAggregate(valueKey string, aggregateType string, value float64) error { + q.metricAggValueKeys = append(q.metricAggValueKeys, valueKey) + q.metricAggTypes = append(q.metricAggTypes, aggregateType) + q.metricAggValues = append(q.metricAggValues, value) + return nil +} + +// Store all the values that you have added. You cannot save if no Add*() +// functions have been called. +// +// Each call to Store() will create a new unique Mako Run and store all +// Aggregate and SamplePoint data registered using the Add* methods since the +// last call to Store() as a part of that new Run. +// +// Data can be added via Add* calls in any order. +// +// An error is returned if the Store call encountered an error. See the +// QuickstoreOutput proto buffer also returned for more information about the +// failure. +func (q *Quickstore) Store() (qpb.QuickstoreOutput, error) { + // Workaround for b/137108136 to make errors in Go logs about flags not being parsed go away. + if !flag.Parsed() { + // It's possible users are using some other flag library and/or are purposely not calling flag.Parse() for some other reason which would result in a call to flag.Parse() failing. + // Instead of exiting, set things up so that we can just log the error and continue. + flag.CommandLine.Init(os.Args[0], flag.ContinueOnError) + if err := flag.CommandLine.Parse(os.Args[1:]); err != nil { + log.Errorf("Error parsing flags: %v", err) + } + } + save := q.saverImpl + + if q.BenchmarkKey != "" { + q.Input.BenchmarkKey = proto.String(q.BenchmarkKey) + } + + log.Info("Attempting to store:") + log.Infof("%d SamplePoints", len(q.samplePoints)) + log.Infof("%d SampleErrors", len(q.sampleErrors)) + log.Infof("%d Run Aggregates", len(q.runAggregates)) + log.Infof("%d Metric Aggregates", len(q.metricAggTypes)) + + out, err := save.Save(&q.Input, q.samplePoints, q.sampleErrors, q.runAggregates, q.metricAggValueKeys, q.metricAggTypes, q.metricAggValues) + + // Reset state for next call + q.samplePoints = nil + q.sampleErrors = nil + q.runAggregates = nil + q.metricAggValueKeys = nil + q.metricAggTypes = nil + q.metricAggValues = nil + + // Turn anything not a successful status into an error + if err == nil && out.GetStatus() != qpb.QuickstoreOutput_SUCCESS { + err = errors.New(out.GetSummaryOutput()) + } + + return out, err +} + +// For dependency injection during unit tests. +type saver interface { + Save(*qpb.QuickstoreInput, + []*pgpb.SamplePoint, + []*pgpb.SampleError, + []*pgpb.KeyedValue, + // Metric aggregate value keys + []string, + // Metric aggregate types + []string, + // Metric aggregate values + []float64) (qpb.QuickstoreOutput, error) +} + +type grpcSaver struct { + client qspb.QuickstoreClient +} + +func (s *grpcSaver) Save(input *qpb.QuickstoreInput, + samplePoints []*pgpb.SamplePoint, + sampleErrors []*pgpb.SampleError, + runAggregates []*pgpb.KeyedValue, + metricAggValueKeys []string, + metricAggTypes []string, + metricAggValues []float64) (qpb.QuickstoreOutput, error) { + + response, err := s.client.Store(context.Background(), + &qspb.StoreInput{ + QuickstoreInput: input, + SamplePoints: samplePoints, + SampleErrors: sampleErrors, + RunAggregates: runAggregates, + AggregateValueKeys: metricAggValueKeys, + AggregateValueTypes: metricAggTypes, + AggregateValueValues: metricAggValues, + }) + + if err != nil { + return qpb.QuickstoreOutput{}, err + } + + if response.GetQuickstoreOutput() == nil { + return qpb.QuickstoreOutput{}, nil + } + + return *response.GetQuickstoreOutput(), nil +} diff --git a/vendor/github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto/quickstore.pb.go b/vendor/github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto/quickstore.pb.go new file mode 100755 index 000000000..fabc8fb83 --- /dev/null +++ b/vendor/github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto/quickstore.pb.go @@ -0,0 +1,441 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: helpers/proto/quickstore/quickstore.proto + +package mako_helpers_quickstore + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + threshold_analyzer_go_proto "github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto" + utest_analyzer_go_proto "github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto" + window_deviation_go_proto "github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto" + mako_go_proto "github.com/google/mako/spec/proto/mako_go_proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type QuickstoreOutput_Status int32 + +const ( + QuickstoreOutput_SUCCESS QuickstoreOutput_Status = 1 + QuickstoreOutput_ERROR QuickstoreOutput_Status = 2 + QuickstoreOutput_ANALYSIS_FAIL QuickstoreOutput_Status = 4 +) + +var QuickstoreOutput_Status_name = map[int32]string{ + 1: "SUCCESS", + 2: "ERROR", + 4: "ANALYSIS_FAIL", +} + +var QuickstoreOutput_Status_value = map[string]int32{ + "SUCCESS": 1, + "ERROR": 2, + "ANALYSIS_FAIL": 4, +} + +func (x QuickstoreOutput_Status) Enum() *QuickstoreOutput_Status { + p := new(QuickstoreOutput_Status) + *p = x + return p +} + +func (x QuickstoreOutput_Status) String() string { + return proto.EnumName(QuickstoreOutput_Status_name, int32(x)) +} + +func (x *QuickstoreOutput_Status) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(QuickstoreOutput_Status_value, data, "QuickstoreOutput_Status") + if err != nil { + return err + } + *x = QuickstoreOutput_Status(value) + return nil +} + +func (QuickstoreOutput_Status) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_80085657127ac5d8, []int{1, 0} +} + +type QuickstoreInput struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + TimestampMs *float64 `protobuf:"fixed64,2,opt,name=timestamp_ms,json=timestampMs" json:"timestamp_ms,omitempty"` + BuildId *int64 `protobuf:"varint,20,opt,name=build_id,json=buildId" json:"build_id,omitempty"` + DurationTimeMs *float64 `protobuf:"fixed64,3,opt,name=duration_time_ms,json=durationTimeMs" json:"duration_time_ms,omitempty"` + Tags []string `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"` + HoverText *string `protobuf:"bytes,14,opt,name=hover_text,json=hoverText" json:"hover_text,omitempty"` + Description *string `protobuf:"bytes,6,opt,name=description" json:"description,omitempty"` + TestPassId *string `protobuf:"bytes,18,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"` + AnnotationList []*mako_go_proto.RunAnnotation `protobuf:"bytes,7,rep,name=annotation_list,json=annotationList" json:"annotation_list,omitempty"` + HyperlinkList []*mako_go_proto.NamedData `protobuf:"bytes,8,rep,name=hyperlink_list,json=hyperlinkList" json:"hyperlink_list,omitempty"` + AuxData []*mako_go_proto.NamedData `protobuf:"bytes,17,rep,name=aux_data,json=auxData" json:"aux_data,omitempty"` + IgnoreRangeList []*mako_go_proto.LabeledRange `protobuf:"bytes,9,rep,name=ignore_range_list,json=ignoreRangeList" json:"ignore_range_list,omitempty"` + TempDir *string `protobuf:"bytes,21,opt,name=temp_dir,json=tempDir" json:"temp_dir,omitempty"` + DeleteSampleFiles *bool `protobuf:"varint,22,opt,name=delete_sample_files,json=deleteSampleFiles,def=1" json:"delete_sample_files,omitempty"` + AnalysisPass *QuickstoreInput_ConditionalFields `protobuf:"bytes,10,opt,name=analysis_pass,json=analysisPass" json:"analysis_pass,omitempty"` + AnalysisFail *QuickstoreInput_ConditionalFields `protobuf:"bytes,11,opt,name=analysis_fail,json=analysisFail" json:"analysis_fail,omitempty"` + ThresholdInputs []*threshold_analyzer_go_proto.ThresholdAnalyzerInput `protobuf:"bytes,12,rep,name=threshold_inputs,json=thresholdInputs" json:"threshold_inputs,omitempty"` + WdaInputs []*window_deviation_go_proto.WindowDeviationInput `protobuf:"bytes,13,rep,name=wda_inputs,json=wdaInputs" json:"wda_inputs,omitempty"` + UtestInputs []*utest_analyzer_go_proto.UTestAnalyzerInput `protobuf:"bytes,16,rep,name=utest_inputs,json=utestInputs" json:"utest_inputs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QuickstoreInput) Reset() { *m = QuickstoreInput{} } +func (m *QuickstoreInput) String() string { return proto.CompactTextString(m) } +func (*QuickstoreInput) ProtoMessage() {} +func (*QuickstoreInput) Descriptor() ([]byte, []int) { + return fileDescriptor_80085657127ac5d8, []int{0} +} + +func (m *QuickstoreInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QuickstoreInput.Unmarshal(m, b) +} +func (m *QuickstoreInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QuickstoreInput.Marshal(b, m, deterministic) +} +func (m *QuickstoreInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuickstoreInput.Merge(m, src) +} +func (m *QuickstoreInput) XXX_Size() int { + return xxx_messageInfo_QuickstoreInput.Size(m) +} +func (m *QuickstoreInput) XXX_DiscardUnknown() { + xxx_messageInfo_QuickstoreInput.DiscardUnknown(m) +} + +var xxx_messageInfo_QuickstoreInput proto.InternalMessageInfo + +const Default_QuickstoreInput_DeleteSampleFiles bool = true + +func (m *QuickstoreInput) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *QuickstoreInput) GetTimestampMs() float64 { + if m != nil && m.TimestampMs != nil { + return *m.TimestampMs + } + return 0 +} + +func (m *QuickstoreInput) GetBuildId() int64 { + if m != nil && m.BuildId != nil { + return *m.BuildId + } + return 0 +} + +func (m *QuickstoreInput) GetDurationTimeMs() float64 { + if m != nil && m.DurationTimeMs != nil { + return *m.DurationTimeMs + } + return 0 +} + +func (m *QuickstoreInput) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *QuickstoreInput) GetHoverText() string { + if m != nil && m.HoverText != nil { + return *m.HoverText + } + return "" +} + +func (m *QuickstoreInput) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *QuickstoreInput) GetTestPassId() string { + if m != nil && m.TestPassId != nil { + return *m.TestPassId + } + return "" +} + +func (m *QuickstoreInput) GetAnnotationList() []*mako_go_proto.RunAnnotation { + if m != nil { + return m.AnnotationList + } + return nil +} + +func (m *QuickstoreInput) GetHyperlinkList() []*mako_go_proto.NamedData { + if m != nil { + return m.HyperlinkList + } + return nil +} + +func (m *QuickstoreInput) GetAuxData() []*mako_go_proto.NamedData { + if m != nil { + return m.AuxData + } + return nil +} + +func (m *QuickstoreInput) GetIgnoreRangeList() []*mako_go_proto.LabeledRange { + if m != nil { + return m.IgnoreRangeList + } + return nil +} + +func (m *QuickstoreInput) GetTempDir() string { + if m != nil && m.TempDir != nil { + return *m.TempDir + } + return "" +} + +func (m *QuickstoreInput) GetDeleteSampleFiles() bool { + if m != nil && m.DeleteSampleFiles != nil { + return *m.DeleteSampleFiles + } + return Default_QuickstoreInput_DeleteSampleFiles +} + +func (m *QuickstoreInput) GetAnalysisPass() *QuickstoreInput_ConditionalFields { + if m != nil { + return m.AnalysisPass + } + return nil +} + +func (m *QuickstoreInput) GetAnalysisFail() *QuickstoreInput_ConditionalFields { + if m != nil { + return m.AnalysisFail + } + return nil +} + +func (m *QuickstoreInput) GetThresholdInputs() []*threshold_analyzer_go_proto.ThresholdAnalyzerInput { + if m != nil { + return m.ThresholdInputs + } + return nil +} + +func (m *QuickstoreInput) GetWdaInputs() []*window_deviation_go_proto.WindowDeviationInput { + if m != nil { + return m.WdaInputs + } + return nil +} + +func (m *QuickstoreInput) GetUtestInputs() []*utest_analyzer_go_proto.UTestAnalyzerInput { + if m != nil { + return m.UtestInputs + } + return nil +} + +type QuickstoreInput_ConditionalFields struct { + Tags []string `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QuickstoreInput_ConditionalFields) Reset() { *m = QuickstoreInput_ConditionalFields{} } +func (m *QuickstoreInput_ConditionalFields) String() string { return proto.CompactTextString(m) } +func (*QuickstoreInput_ConditionalFields) ProtoMessage() {} +func (*QuickstoreInput_ConditionalFields) Descriptor() ([]byte, []int) { + return fileDescriptor_80085657127ac5d8, []int{0, 0} +} + +func (m *QuickstoreInput_ConditionalFields) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QuickstoreInput_ConditionalFields.Unmarshal(m, b) +} +func (m *QuickstoreInput_ConditionalFields) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QuickstoreInput_ConditionalFields.Marshal(b, m, deterministic) +} +func (m *QuickstoreInput_ConditionalFields) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuickstoreInput_ConditionalFields.Merge(m, src) +} +func (m *QuickstoreInput_ConditionalFields) XXX_Size() int { + return xxx_messageInfo_QuickstoreInput_ConditionalFields.Size(m) +} +func (m *QuickstoreInput_ConditionalFields) XXX_DiscardUnknown() { + xxx_messageInfo_QuickstoreInput_ConditionalFields.DiscardUnknown(m) +} + +var xxx_messageInfo_QuickstoreInput_ConditionalFields proto.InternalMessageInfo + +func (m *QuickstoreInput_ConditionalFields) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +type QuickstoreOutput struct { + Status *QuickstoreOutput_Status `protobuf:"varint,1,opt,name=status,enum=mako.helpers.quickstore.QuickstoreOutput_Status" json:"status,omitempty"` + AnalyzerOutputList []*mako_go_proto.AnalyzerOutput `protobuf:"bytes,2,rep,name=analyzer_output_list,json=analyzerOutputList" json:"analyzer_output_list,omitempty"` + SummaryOutput *string `protobuf:"bytes,3,opt,name=summary_output,json=summaryOutput" json:"summary_output,omitempty"` + RunChartLink *string `protobuf:"bytes,4,opt,name=run_chart_link,json=runChartLink" json:"run_chart_link,omitempty"` + RunKey *string `protobuf:"bytes,5,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + GeneratedSampleFiles []string `protobuf:"bytes,6,rep,name=generated_sample_files,json=generatedSampleFiles" json:"generated_sample_files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QuickstoreOutput) Reset() { *m = QuickstoreOutput{} } +func (m *QuickstoreOutput) String() string { return proto.CompactTextString(m) } +func (*QuickstoreOutput) ProtoMessage() {} +func (*QuickstoreOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_80085657127ac5d8, []int{1} +} + +func (m *QuickstoreOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QuickstoreOutput.Unmarshal(m, b) +} +func (m *QuickstoreOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QuickstoreOutput.Marshal(b, m, deterministic) +} +func (m *QuickstoreOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuickstoreOutput.Merge(m, src) +} +func (m *QuickstoreOutput) XXX_Size() int { + return xxx_messageInfo_QuickstoreOutput.Size(m) +} +func (m *QuickstoreOutput) XXX_DiscardUnknown() { + xxx_messageInfo_QuickstoreOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_QuickstoreOutput proto.InternalMessageInfo + +func (m *QuickstoreOutput) GetStatus() QuickstoreOutput_Status { + if m != nil && m.Status != nil { + return *m.Status + } + return QuickstoreOutput_SUCCESS +} + +func (m *QuickstoreOutput) GetAnalyzerOutputList() []*mako_go_proto.AnalyzerOutput { + if m != nil { + return m.AnalyzerOutputList + } + return nil +} + +func (m *QuickstoreOutput) GetSummaryOutput() string { + if m != nil && m.SummaryOutput != nil { + return *m.SummaryOutput + } + return "" +} + +func (m *QuickstoreOutput) GetRunChartLink() string { + if m != nil && m.RunChartLink != nil { + return *m.RunChartLink + } + return "" +} + +func (m *QuickstoreOutput) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *QuickstoreOutput) GetGeneratedSampleFiles() []string { + if m != nil { + return m.GeneratedSampleFiles + } + return nil +} + +func init() { + proto.RegisterEnum("mako.helpers.quickstore.QuickstoreOutput_Status", QuickstoreOutput_Status_name, QuickstoreOutput_Status_value) + proto.RegisterType((*QuickstoreInput)(nil), "mako.helpers.quickstore.QuickstoreInput") + proto.RegisterType((*QuickstoreInput_ConditionalFields)(nil), "mako.helpers.quickstore.QuickstoreInput.ConditionalFields") + proto.RegisterType((*QuickstoreOutput)(nil), "mako.helpers.quickstore.QuickstoreOutput") +} + +func init() { + proto.RegisterFile("helpers/proto/quickstore/quickstore.proto", fileDescriptor_80085657127ac5d8) +} + +var fileDescriptor_80085657127ac5d8 = []byte{ + // 874 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xdf, 0x6f, 0x1b, 0x45, + 0x10, 0x96, 0x13, 0xc7, 0x3f, 0xd6, 0xbf, 0xce, 0x1b, 0xb7, 0xbd, 0x46, 0x42, 0x32, 0x01, 0x54, + 0x43, 0xe1, 0x5a, 0x85, 0x0a, 0x89, 0x0a, 0x21, 0x99, 0xa4, 0x16, 0x0e, 0x6e, 0x0b, 0xe7, 0x54, + 0x88, 0xa7, 0xd3, 0xc6, 0x3b, 0xb1, 0x57, 0xbe, 0xdb, 0x3b, 0x76, 0xf7, 0x9a, 0x98, 0x7f, 0x8f, + 0xbf, 0x89, 0x77, 0xb4, 0xb3, 0xf6, 0x39, 0x4e, 0x1b, 0x89, 0x07, 0xde, 0x76, 0x66, 0xbe, 0xef, + 0x9b, 0xd9, 0xd9, 0x9d, 0x21, 0x5f, 0x2e, 0x20, 0xce, 0x40, 0xe9, 0x67, 0x99, 0x4a, 0x4d, 0xfa, + 0xec, 0xcf, 0x5c, 0xcc, 0x96, 0xda, 0xa4, 0x0a, 0x6e, 0x1d, 0x03, 0x8c, 0xd1, 0x47, 0x09, 0x5b, + 0xa6, 0xc1, 0x1a, 0x1f, 0x6c, 0xc3, 0x47, 0xcf, 0x67, 0xb1, 0x00, 0x69, 0x36, 0x1a, 0x4c, 0xb2, + 0x78, 0xf5, 0x97, 0xd5, 0x34, 0x0b, 0x05, 0x7a, 0x91, 0xc6, 0x3c, 0xda, 0xf8, 0x9c, 0xd4, 0xd1, + 0xd7, 0xf7, 0x31, 0x72, 0x03, 0xda, 0xdc, 0x45, 0x07, 0xf7, 0xa1, 0xaf, 0x85, 0xe4, 0xe9, 0x75, + 0xc4, 0xe1, 0xbd, 0x60, 0x46, 0xa4, 0x72, 0x8d, 0x7f, 0xa0, 0x33, 0x98, 0xad, 0xc1, 0x58, 0x33, + 0x1e, 0x8f, 0xff, 0xae, 0x91, 0xce, 0x6f, 0x45, 0xd5, 0x63, 0x99, 0xe5, 0x86, 0x7e, 0x46, 0x5a, + 0x97, 0x20, 0x67, 0x8b, 0x84, 0xa9, 0x65, 0xb4, 0x84, 0x95, 0x5f, 0xea, 0x97, 0x06, 0xf5, 0xb0, + 0x59, 0x38, 0x7f, 0x81, 0x15, 0xfd, 0x94, 0x34, 0x8d, 0x48, 0x40, 0x1b, 0x96, 0x64, 0x51, 0xa2, + 0xfd, 0xbd, 0x7e, 0x69, 0x50, 0x0a, 0x1b, 0x85, 0xef, 0xb5, 0xa6, 0x8f, 0x49, 0xed, 0x32, 0x17, + 0x31, 0x8f, 0x04, 0xf7, 0x7b, 0xfd, 0xd2, 0x60, 0x3f, 0xac, 0xa2, 0x3d, 0xe6, 0x74, 0x40, 0x3c, + 0x9e, 0x2b, 0xac, 0x2f, 0xb2, 0x14, 0xab, 0xb0, 0x8f, 0x0a, 0xed, 0x8d, 0xff, 0x42, 0x24, 0xf0, + 0x5a, 0x53, 0x4a, 0xca, 0x86, 0xcd, 0xb5, 0x5f, 0xee, 0xef, 0x0f, 0xea, 0x21, 0x9e, 0xe9, 0x27, + 0x84, 0x2c, 0xd2, 0xf7, 0xa0, 0x22, 0x03, 0x37, 0xc6, 0x6f, 0x63, 0x75, 0x75, 0xf4, 0x5c, 0xc0, + 0x8d, 0xa1, 0x7d, 0xd2, 0xe0, 0xa0, 0x67, 0x4a, 0x64, 0x56, 0xc7, 0xaf, 0x60, 0xfc, 0xb6, 0x8b, + 0xf6, 0x49, 0x13, 0x7b, 0x9a, 0x31, 0xad, 0x6d, 0x75, 0x14, 0x21, 0xc4, 0xfa, 0x7e, 0x65, 0x5a, + 0x8f, 0x39, 0xfd, 0x81, 0x74, 0x98, 0x94, 0xa9, 0x71, 0x25, 0xc6, 0x42, 0x1b, 0xbf, 0xda, 0xdf, + 0x1f, 0x34, 0x4e, 0x0e, 0x03, 0xec, 0x5e, 0x98, 0xcb, 0x61, 0x11, 0x0f, 0xdb, 0x5b, 0xec, 0x44, + 0x68, 0x43, 0xbf, 0x23, 0xed, 0xc5, 0x2a, 0x03, 0x15, 0x0b, 0xb9, 0x74, 0xe4, 0x1a, 0x92, 0x3b, + 0x8e, 0xfc, 0x86, 0x25, 0xc0, 0xcf, 0x98, 0x61, 0x61, 0xab, 0x80, 0x21, 0xef, 0x2b, 0x52, 0x63, + 0xf9, 0x4d, 0xc4, 0x99, 0x61, 0x7e, 0xf7, 0xe3, 0x8c, 0x2a, 0xcb, 0x6f, 0xec, 0x81, 0xfe, 0x48, + 0xba, 0x62, 0x2e, 0x53, 0x05, 0x91, 0x62, 0x72, 0x0e, 0x2e, 0x4d, 0x1d, 0x49, 0xd4, 0x91, 0x26, + 0xec, 0x12, 0x62, 0xe0, 0xa1, 0x0d, 0x87, 0x1d, 0x07, 0x46, 0x03, 0x73, 0x3d, 0x26, 0x35, 0x03, + 0x49, 0x16, 0x71, 0xa1, 0xfc, 0x07, 0x78, 0xff, 0xaa, 0xb5, 0xcf, 0x84, 0xa2, 0x2f, 0xc8, 0x21, + 0x87, 0x18, 0x0c, 0x44, 0x9a, 0x25, 0x59, 0x0c, 0xd1, 0x95, 0x88, 0x41, 0xfb, 0x0f, 0xfb, 0xa5, + 0x41, 0xed, 0x65, 0xd9, 0xa8, 0x1c, 0xc2, 0xae, 0x03, 0x4c, 0x31, 0x3e, 0xb2, 0x61, 0x1a, 0x91, + 0x16, 0xfe, 0x42, 0x2d, 0x34, 0x36, 0xd6, 0x27, 0xfd, 0xd2, 0xa0, 0x71, 0xf2, 0x32, 0xb8, 0x67, + 0x44, 0x82, 0x3b, 0xff, 0x2e, 0x38, 0x4d, 0x25, 0x17, 0xb6, 0x87, 0x2c, 0x1e, 0x09, 0x88, 0xb9, + 0x0e, 0x9b, 0x1b, 0x41, 0xfb, 0x2a, 0x3b, 0x09, 0xae, 0x98, 0x88, 0xfd, 0xc6, 0xff, 0x97, 0x60, + 0xc4, 0x44, 0x4c, 0x39, 0xf1, 0xb6, 0xd3, 0x29, 0x2c, 0x45, 0xfb, 0x4d, 0xec, 0xe8, 0xf7, 0x2e, + 0x47, 0x31, 0x65, 0xc1, 0x47, 0xa6, 0xf8, 0x62, 0xe3, 0x1a, 0xae, 0x3d, 0x98, 0x34, 0xec, 0x14, + 0x50, 0xb4, 0x35, 0x3d, 0x27, 0xe4, 0x9a, 0xb3, 0x8d, 0x7e, 0x0b, 0xf5, 0x9f, 0x3a, 0xfd, 0x0f, + 0x66, 0xf7, 0x77, 0x74, 0x9c, 0x6d, 0x6c, 0xa7, 0x58, 0xbf, 0xe6, 0xac, 0xd0, 0x6a, 0xba, 0xed, + 0xb0, 0x56, 0xf3, 0x50, 0xed, 0x89, 0x53, 0xbb, 0xb3, 0x37, 0xde, 0x5d, 0x80, 0x36, 0xbb, 0xb5, + 0x35, 0x10, 0xe2, 0xb4, 0x8e, 0x9e, 0x90, 0xee, 0x07, 0x0d, 0x2a, 0xc6, 0xaf, 0xb4, 0x1d, 0xbf, + 0xf3, 0x72, 0xad, 0xe3, 0x79, 0xe7, 0xe5, 0xda, 0xa1, 0xd7, 0x3b, 0x2f, 0xd7, 0x0e, 0xbc, 0xca, + 0xf1, 0x3f, 0x7b, 0xc4, 0xdb, 0x36, 0xfb, 0x6d, 0x6e, 0xec, 0x1a, 0xf9, 0x99, 0x54, 0xb4, 0x61, + 0x26, 0xd7, 0xb8, 0x3f, 0xda, 0x27, 0xcf, 0xff, 0xc3, 0x3b, 0x39, 0x6a, 0x30, 0x45, 0x5e, 0xb8, + 0xe6, 0xd3, 0x11, 0xe9, 0x6d, 0x6e, 0x11, 0xa5, 0x88, 0x70, 0xbf, 0x7d, 0x0f, 0x6f, 0xdb, 0x73, + 0xba, 0x9b, 0x9b, 0x39, 0x89, 0x90, 0xb2, 0x1d, 0x1b, 0xbf, 0xfc, 0x17, 0xa4, 0xad, 0xf3, 0x24, + 0x61, 0x6a, 0xb5, 0x96, 0xc1, 0x9d, 0x53, 0x0f, 0x5b, 0x6b, 0xef, 0xba, 0xf0, 0xcf, 0x49, 0x5b, + 0xe5, 0x32, 0x9a, 0x2d, 0x98, 0xb2, 0x89, 0xe4, 0xd2, 0x2f, 0xbb, 0x05, 0xa8, 0x72, 0x79, 0x6a, + 0x9d, 0x13, 0x21, 0x97, 0xf4, 0x11, 0xa9, 0x5a, 0x94, 0xdd, 0x8f, 0x07, 0x18, 0xae, 0xa8, 0x5c, + 0xda, 0xcd, 0xf8, 0x82, 0x3c, 0x9c, 0x83, 0x04, 0xc5, 0x0c, 0xf0, 0xdd, 0x01, 0xaa, 0x60, 0x13, + 0x7b, 0x45, 0xf4, 0xd6, 0xf4, 0x1c, 0x7f, 0x4b, 0x2a, 0xee, 0xd6, 0xb4, 0x41, 0xaa, 0xd3, 0x77, + 0xa7, 0xa7, 0xaf, 0xa6, 0x53, 0xaf, 0x44, 0xeb, 0xe4, 0xe0, 0x55, 0x18, 0xbe, 0x0d, 0xbd, 0x3d, + 0xda, 0x25, 0xad, 0xe1, 0x9b, 0xe1, 0xe4, 0x8f, 0xe9, 0x78, 0x1a, 0x8d, 0x86, 0xe3, 0x89, 0x57, + 0xfe, 0xe9, 0x1b, 0xf2, 0x74, 0x96, 0x26, 0xc1, 0x3c, 0x4d, 0xe7, 0x31, 0x04, 0xf6, 0x2d, 0x85, + 0x9c, 0x07, 0x19, 0xa8, 0xab, 0x54, 0x25, 0x4c, 0xce, 0x60, 0xa7, 0xe5, 0xff, 0x06, 0x00, 0x00, + 0xff, 0xff, 0x23, 0x62, 0xfd, 0xa9, 0xd8, 0x06, 0x00, 0x00, +} diff --git a/vendor/github.com/google/mako/internal/go/common/common_deps.go b/vendor/github.com/google/mako/internal/go/common/common_deps.go new file mode 100644 index 000000000..ad9ede17c --- /dev/null +++ b/vendor/github.com/google/mako/internal/go/common/common_deps.go @@ -0,0 +1,17 @@ +// Copyright 2019 Google LLC +// +// 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 +// +// https://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 common pulls in dependencies that are needed (for their side effects) for all Mako binaries. +// +package common diff --git a/vendor/github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto/quickstore.pb.go b/vendor/github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto/quickstore.pb.go new file mode 100755 index 000000000..0d2dc1cde --- /dev/null +++ b/vendor/github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto/quickstore.pb.go @@ -0,0 +1,360 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: internal/quickstore_microservice/proto/quickstore.proto + +package mako_internal_quickstore_microservice + +import ( + context "context" + fmt "fmt" + proto "github.com/golang/protobuf/proto" + quickstore_go_proto "github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto" + mako_go_proto "github.com/google/mako/spec/proto/mako_go_proto" + grpc "google.golang.org/grpc" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type StoreInput struct { + QuickstoreInput *quickstore_go_proto.QuickstoreInput `protobuf:"bytes,1,opt,name=quickstore_input,json=quickstoreInput" json:"quickstore_input,omitempty"` + SamplePoints []*mako_go_proto.SamplePoint `protobuf:"bytes,2,rep,name=sample_points,json=samplePoints" json:"sample_points,omitempty"` + SampleErrors []*mako_go_proto.SampleError `protobuf:"bytes,3,rep,name=sample_errors,json=sampleErrors" json:"sample_errors,omitempty"` + RunAggregates []*mako_go_proto.KeyedValue `protobuf:"bytes,4,rep,name=run_aggregates,json=runAggregates" json:"run_aggregates,omitempty"` + AggregateValueKeys []string `protobuf:"bytes,5,rep,name=aggregate_value_keys,json=aggregateValueKeys" json:"aggregate_value_keys,omitempty"` + AggregateValueTypes []string `protobuf:"bytes,6,rep,name=aggregate_value_types,json=aggregateValueTypes" json:"aggregate_value_types,omitempty"` + AggregateValueValues []float64 `protobuf:"fixed64,7,rep,name=aggregate_value_values,json=aggregateValueValues" json:"aggregate_value_values,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreInput) Reset() { *m = StoreInput{} } +func (m *StoreInput) String() string { return proto.CompactTextString(m) } +func (*StoreInput) ProtoMessage() {} +func (*StoreInput) Descriptor() ([]byte, []int) { + return fileDescriptor_80613028ee3e5eb0, []int{0} +} + +func (m *StoreInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StoreInput.Unmarshal(m, b) +} +func (m *StoreInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StoreInput.Marshal(b, m, deterministic) +} +func (m *StoreInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreInput.Merge(m, src) +} +func (m *StoreInput) XXX_Size() int { + return xxx_messageInfo_StoreInput.Size(m) +} +func (m *StoreInput) XXX_DiscardUnknown() { + xxx_messageInfo_StoreInput.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreInput proto.InternalMessageInfo + +func (m *StoreInput) GetQuickstoreInput() *quickstore_go_proto.QuickstoreInput { + if m != nil { + return m.QuickstoreInput + } + return nil +} + +func (m *StoreInput) GetSamplePoints() []*mako_go_proto.SamplePoint { + if m != nil { + return m.SamplePoints + } + return nil +} + +func (m *StoreInput) GetSampleErrors() []*mako_go_proto.SampleError { + if m != nil { + return m.SampleErrors + } + return nil +} + +func (m *StoreInput) GetRunAggregates() []*mako_go_proto.KeyedValue { + if m != nil { + return m.RunAggregates + } + return nil +} + +func (m *StoreInput) GetAggregateValueKeys() []string { + if m != nil { + return m.AggregateValueKeys + } + return nil +} + +func (m *StoreInput) GetAggregateValueTypes() []string { + if m != nil { + return m.AggregateValueTypes + } + return nil +} + +func (m *StoreInput) GetAggregateValueValues() []float64 { + if m != nil { + return m.AggregateValueValues + } + return nil +} + +type StoreOutput struct { + QuickstoreOutput *quickstore_go_proto.QuickstoreOutput `protobuf:"bytes,1,opt,name=quickstore_output,json=quickstoreOutput" json:"quickstore_output,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreOutput) Reset() { *m = StoreOutput{} } +func (m *StoreOutput) String() string { return proto.CompactTextString(m) } +func (*StoreOutput) ProtoMessage() {} +func (*StoreOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_80613028ee3e5eb0, []int{1} +} + +func (m *StoreOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StoreOutput.Unmarshal(m, b) +} +func (m *StoreOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StoreOutput.Marshal(b, m, deterministic) +} +func (m *StoreOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreOutput.Merge(m, src) +} +func (m *StoreOutput) XXX_Size() int { + return xxx_messageInfo_StoreOutput.Size(m) +} +func (m *StoreOutput) XXX_DiscardUnknown() { + xxx_messageInfo_StoreOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreOutput proto.InternalMessageInfo + +func (m *StoreOutput) GetQuickstoreOutput() *quickstore_go_proto.QuickstoreOutput { + if m != nil { + return m.QuickstoreOutput + } + return nil +} + +type ShutdownInput struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ShutdownInput) Reset() { *m = ShutdownInput{} } +func (m *ShutdownInput) String() string { return proto.CompactTextString(m) } +func (*ShutdownInput) ProtoMessage() {} +func (*ShutdownInput) Descriptor() ([]byte, []int) { + return fileDescriptor_80613028ee3e5eb0, []int{2} +} + +func (m *ShutdownInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ShutdownInput.Unmarshal(m, b) +} +func (m *ShutdownInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ShutdownInput.Marshal(b, m, deterministic) +} +func (m *ShutdownInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShutdownInput.Merge(m, src) +} +func (m *ShutdownInput) XXX_Size() int { + return xxx_messageInfo_ShutdownInput.Size(m) +} +func (m *ShutdownInput) XXX_DiscardUnknown() { + xxx_messageInfo_ShutdownInput.DiscardUnknown(m) +} + +var xxx_messageInfo_ShutdownInput proto.InternalMessageInfo + +type ShutdownOutput struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ShutdownOutput) Reset() { *m = ShutdownOutput{} } +func (m *ShutdownOutput) String() string { return proto.CompactTextString(m) } +func (*ShutdownOutput) ProtoMessage() {} +func (*ShutdownOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_80613028ee3e5eb0, []int{3} +} + +func (m *ShutdownOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ShutdownOutput.Unmarshal(m, b) +} +func (m *ShutdownOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ShutdownOutput.Marshal(b, m, deterministic) +} +func (m *ShutdownOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShutdownOutput.Merge(m, src) +} +func (m *ShutdownOutput) XXX_Size() int { + return xxx_messageInfo_ShutdownOutput.Size(m) +} +func (m *ShutdownOutput) XXX_DiscardUnknown() { + xxx_messageInfo_ShutdownOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_ShutdownOutput proto.InternalMessageInfo + +func init() { + proto.RegisterType((*StoreInput)(nil), "mako.internal.quickstore_microservice.StoreInput") + proto.RegisterType((*StoreOutput)(nil), "mako.internal.quickstore_microservice.StoreOutput") + proto.RegisterType((*ShutdownInput)(nil), "mako.internal.quickstore_microservice.ShutdownInput") + proto.RegisterType((*ShutdownOutput)(nil), "mako.internal.quickstore_microservice.ShutdownOutput") +} + +func init() { + proto.RegisterFile("internal/quickstore_microservice/proto/quickstore.proto", fileDescriptor_80613028ee3e5eb0) +} + +var fileDescriptor_80613028ee3e5eb0 = []byte{ + // 417 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0xc6, 0x49, 0x4d, 0x41, 0x4c, 0x48, 0x9b, 0x2e, 0x29, 0xb2, 0x72, 0x8a, 0x2c, 0x21, 0xb9, + 0x17, 0x17, 0xac, 0x42, 0xcf, 0x1c, 0x38, 0xa0, 0x0a, 0x01, 0x36, 0xea, 0xd5, 0xb2, 0xdc, 0x51, + 0x6a, 0xc5, 0xf1, 0x6e, 0x77, 0xd6, 0x45, 0x7e, 0x00, 0x78, 0x14, 0x9e, 0x13, 0x79, 0xfc, 0x27, + 0x9b, 0x46, 0x95, 0xd2, 0xcb, 0x6a, 0x77, 0xe6, 0xfb, 0x7d, 0x3b, 0xf6, 0xb7, 0x70, 0x99, 0x97, + 0x06, 0x75, 0x99, 0x16, 0xe7, 0x77, 0x55, 0x9e, 0xad, 0xc8, 0x48, 0x8d, 0xc9, 0x3a, 0xcf, 0xb4, + 0x24, 0xd4, 0xf7, 0x79, 0x86, 0xe7, 0x4a, 0x4b, 0x23, 0xad, 0x6e, 0xc0, 0x05, 0xf1, 0x6e, 0x9d, + 0xae, 0x64, 0xd0, 0xd3, 0xc1, 0x23, 0xf4, 0xfc, 0xec, 0x16, 0x0b, 0x85, 0x9a, 0x76, 0x6c, 0x76, + 0x1c, 0xe7, 0xa7, 0xa4, 0x30, 0xeb, 0x74, 0x6c, 0xce, 0x5b, 0xef, 0x9f, 0x03, 0x10, 0x37, 0xb2, + 0xaf, 0xa5, 0xaa, 0x8c, 0x88, 0x61, 0x6a, 0xdd, 0x95, 0x37, 0x35, 0x77, 0xb4, 0x18, 0xf9, 0xe3, + 0xd0, 0x0f, 0x98, 0xea, 0x2e, 0xb4, 0x26, 0x0a, 0x7e, 0x0e, 0x5b, 0xf6, 0x88, 0x8e, 0xef, 0xb6, + 0x0b, 0xe2, 0x13, 0x4c, 0x28, 0x5d, 0xab, 0x02, 0x13, 0x25, 0xf3, 0xd2, 0x90, 0x7b, 0xb0, 0x70, + 0xfc, 0x71, 0x78, 0xd2, 0x3a, 0xc6, 0xdc, 0xfa, 0xd1, 0x74, 0xa2, 0xd7, 0xb4, 0x39, 0x90, 0xc5, + 0xa1, 0xd6, 0x52, 0x93, 0xeb, 0xec, 0x72, 0x5f, 0x9a, 0x4e, 0xcf, 0xf1, 0x81, 0xc4, 0x25, 0x1c, + 0xe9, 0xaa, 0x4c, 0xd2, 0xe5, 0x52, 0xe3, 0x32, 0x35, 0x48, 0xee, 0x73, 0x06, 0xa7, 0x2d, 0x78, + 0x85, 0x35, 0xde, 0x5c, 0xa7, 0x45, 0x85, 0xd1, 0x44, 0x57, 0xe5, 0xe7, 0x41, 0x26, 0xde, 0xc3, + 0x6c, 0x80, 0x92, 0xfb, 0x46, 0x91, 0xac, 0xb0, 0x26, 0xf7, 0x70, 0xe1, 0xf8, 0xaf, 0x22, 0x31, + 0xf4, 0x18, 0xbe, 0xc2, 0x9a, 0x44, 0x08, 0xa7, 0x0f, 0x09, 0x53, 0x2b, 0x24, 0xf7, 0x05, 0x23, + 0x6f, 0xb6, 0x91, 0x5f, 0x4d, 0x4b, 0x5c, 0xc0, 0xdb, 0x87, 0x0c, 0xaf, 0xe4, 0xbe, 0x5c, 0x38, + 0xfe, 0x28, 0x9a, 0x6d, 0x43, 0xbc, 0x90, 0x87, 0x30, 0xe6, 0x9c, 0xbe, 0x57, 0xa6, 0xf9, 0xa7, + 0xd7, 0x70, 0x62, 0x05, 0x25, 0xb9, 0xd8, 0x25, 0x75, 0xb6, 0x47, 0x52, 0xad, 0x4b, 0x64, 0x85, + 0xdd, 0x56, 0xbc, 0x63, 0x98, 0xc4, 0xb7, 0x95, 0xb9, 0x91, 0xbf, 0x4b, 0x0e, 0xcf, 0x9b, 0xc2, + 0x51, 0x5f, 0x68, 0x25, 0xe1, 0xdf, 0x03, 0x80, 0x8d, 0x93, 0x50, 0x70, 0xc8, 0x83, 0x89, 0x0f, + 0xc1, 0x5e, 0x8f, 0x36, 0xd8, 0x3c, 0xb7, 0x79, 0xf8, 0x14, 0xa4, 0x9b, 0xf0, 0x99, 0xf8, 0x33, + 0x82, 0x59, 0x3f, 0xd3, 0x37, 0x4b, 0x26, 0x2e, 0xf6, 0xb5, 0xb3, 0xbf, 0x70, 0xfe, 0xf1, 0x89, + 0x54, 0x3f, 0xc7, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x61, 0x39, 0xec, 0x89, 0xde, 0x03, 0x00, + 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QuickstoreClient is the client API for Quickstore service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QuickstoreClient interface { + Store(ctx context.Context, in *StoreInput, opts ...grpc.CallOption) (*StoreOutput, error) + ShutdownMicroservice(ctx context.Context, in *ShutdownInput, opts ...grpc.CallOption) (*ShutdownOutput, error) +} + +type quickstoreClient struct { + cc *grpc.ClientConn +} + +func NewQuickstoreClient(cc *grpc.ClientConn) QuickstoreClient { + return &quickstoreClient{cc} +} + +func (c *quickstoreClient) Store(ctx context.Context, in *StoreInput, opts ...grpc.CallOption) (*StoreOutput, error) { + out := new(StoreOutput) + err := c.cc.Invoke(ctx, "/mako.internal.quickstore_microservice.Quickstore/Store", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *quickstoreClient) ShutdownMicroservice(ctx context.Context, in *ShutdownInput, opts ...grpc.CallOption) (*ShutdownOutput, error) { + out := new(ShutdownOutput) + err := c.cc.Invoke(ctx, "/mako.internal.quickstore_microservice.Quickstore/ShutdownMicroservice", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QuickstoreServer is the server API for Quickstore service. +type QuickstoreServer interface { + Store(context.Context, *StoreInput) (*StoreOutput, error) + ShutdownMicroservice(context.Context, *ShutdownInput) (*ShutdownOutput, error) +} + +func RegisterQuickstoreServer(s *grpc.Server, srv QuickstoreServer) { + s.RegisterService(&_Quickstore_serviceDesc, srv) +} + +func _Quickstore_Store_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreInput) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QuickstoreServer).Store(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/mako.internal.quickstore_microservice.Quickstore/Store", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QuickstoreServer).Store(ctx, req.(*StoreInput)) + } + return interceptor(ctx, in, info, handler) +} + +func _Quickstore_ShutdownMicroservice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ShutdownInput) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QuickstoreServer).ShutdownMicroservice(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/mako.internal.quickstore_microservice.Quickstore/ShutdownMicroservice", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QuickstoreServer).ShutdownMicroservice(ctx, req.(*ShutdownInput)) + } + return interceptor(ctx, in, info, handler) +} + +var _Quickstore_serviceDesc = grpc.ServiceDesc{ + ServiceName: "mako.internal.quickstore_microservice.Quickstore", + HandlerType: (*QuickstoreServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Store", + Handler: _Quickstore_Store_Handler, + }, + { + MethodName: "ShutdownMicroservice", + Handler: _Quickstore_ShutdownMicroservice_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "internal/quickstore_microservice/proto/quickstore.proto", +} diff --git a/vendor/github.com/google/mako/spec/proto/mako_go_proto/mako.pb.go b/vendor/github.com/google/mako/spec/proto/mako_go_proto/mako.pb.go new file mode 100755 index 000000000..0437f5e97 --- /dev/null +++ b/vendor/github.com/google/mako/spec/proto/mako_go_proto/mako.pb.go @@ -0,0 +1,4052 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: spec/proto/mako.proto + +package mako + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type RunOrder int32 + +const ( + RunOrder_UNSPECIFIED RunOrder = 0 + RunOrder_TIMESTAMP RunOrder = 1 + RunOrder_BUILD_ID RunOrder = 2 +) + +var RunOrder_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "TIMESTAMP", + 2: "BUILD_ID", +} + +var RunOrder_value = map[string]int32{ + "UNSPECIFIED": 0, + "TIMESTAMP": 1, + "BUILD_ID": 2, +} + +func (x RunOrder) Enum() *RunOrder { + p := new(RunOrder) + *p = x + return p +} + +func (x RunOrder) String() string { + return proto.EnumName(RunOrder_name, int32(x)) +} + +func (x *RunOrder) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RunOrder_value, data, "RunOrder") + if err != nil { + return err + } + *x = RunOrder(value) + return nil +} + +func (RunOrder) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{0} +} + +type Status_Code int32 + +const ( + Status_SUCCESS Status_Code = 0 + Status_FAIL Status_Code = 1 +) + +var Status_Code_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAIL", +} + +var Status_Code_value = map[string]int32{ + "SUCCESS": 0, + "FAIL": 1, +} + +func (x Status_Code) Enum() *Status_Code { + p := new(Status_Code) + *p = x + return p +} + +func (x Status_Code) String() string { + return proto.EnumName(Status_Code_name, int32(x)) +} + +func (x *Status_Code) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Status_Code_value, data, "Status_Code") + if err != nil { + return err + } + *x = Status_Code(value) + return nil +} + +func (Status_Code) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{0, 0} +} + +type ValueInfo_Type int32 + +const ( + ValueInfo_NUMERIC ValueInfo_Type = 1 + ValueInfo_TIMESTAMP ValueInfo_Type = 2 +) + +var ValueInfo_Type_name = map[int32]string{ + 1: "NUMERIC", + 2: "TIMESTAMP", +} + +var ValueInfo_Type_value = map[string]int32{ + "NUMERIC": 1, + "TIMESTAMP": 2, +} + +func (x ValueInfo_Type) Enum() *ValueInfo_Type { + p := new(ValueInfo_Type) + *p = x + return p +} + +func (x ValueInfo_Type) String() string { + return proto.EnumName(ValueInfo_Type_name, int32(x)) +} + +func (x *ValueInfo_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ValueInfo_Type_value, data, "ValueInfo_Type") + if err != nil { + return err + } + *x = ValueInfo_Type(value) + return nil +} + +func (ValueInfo_Type) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{1, 0} +} + +type DataFilter_DataType int32 + +const ( + DataFilter_METRIC_AGGREGATE_COUNT DataFilter_DataType = 11 + DataFilter_METRIC_AGGREGATE_MIN DataFilter_DataType = 1 + DataFilter_METRIC_AGGREGATE_MAX DataFilter_DataType = 2 + DataFilter_METRIC_AGGREGATE_MEAN DataFilter_DataType = 3 + DataFilter_METRIC_AGGREGATE_MEDIAN DataFilter_DataType = 4 + DataFilter_METRIC_AGGREGATE_STDDEV DataFilter_DataType = 5 + DataFilter_METRIC_AGGREGATE_MAD DataFilter_DataType = 12 + DataFilter_METRIC_AGGREGATE_PERCENTILE DataFilter_DataType = 6 + DataFilter_CUSTOM_AGGREGATE DataFilter_DataType = 7 + DataFilter_METRIC_SAMPLEPOINTS DataFilter_DataType = 8 + DataFilter_BENCHMARK_SCORE DataFilter_DataType = 9 + DataFilter_ERROR_COUNT DataFilter_DataType = 10 +) + +var DataFilter_DataType_name = map[int32]string{ + 11: "METRIC_AGGREGATE_COUNT", + 1: "METRIC_AGGREGATE_MIN", + 2: "METRIC_AGGREGATE_MAX", + 3: "METRIC_AGGREGATE_MEAN", + 4: "METRIC_AGGREGATE_MEDIAN", + 5: "METRIC_AGGREGATE_STDDEV", + 12: "METRIC_AGGREGATE_MAD", + 6: "METRIC_AGGREGATE_PERCENTILE", + 7: "CUSTOM_AGGREGATE", + 8: "METRIC_SAMPLEPOINTS", + 9: "BENCHMARK_SCORE", + 10: "ERROR_COUNT", +} + +var DataFilter_DataType_value = map[string]int32{ + "METRIC_AGGREGATE_COUNT": 11, + "METRIC_AGGREGATE_MIN": 1, + "METRIC_AGGREGATE_MAX": 2, + "METRIC_AGGREGATE_MEAN": 3, + "METRIC_AGGREGATE_MEDIAN": 4, + "METRIC_AGGREGATE_STDDEV": 5, + "METRIC_AGGREGATE_MAD": 12, + "METRIC_AGGREGATE_PERCENTILE": 6, + "CUSTOM_AGGREGATE": 7, + "METRIC_SAMPLEPOINTS": 8, + "BENCHMARK_SCORE": 9, + "ERROR_COUNT": 10, +} + +func (x DataFilter_DataType) Enum() *DataFilter_DataType { + p := new(DataFilter_DataType) + *p = x + return p +} + +func (x DataFilter_DataType) String() string { + return proto.EnumName(DataFilter_DataType_name, int32(x)) +} + +func (x *DataFilter_DataType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DataFilter_DataType_value, data, "DataFilter_DataType") + if err != nil { + return err + } + *x = DataFilter_DataType(value) + return nil +} + +func (DataFilter_DataType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{6, 0} +} + +type AnalysisTriageInfo_AnalysisTriageType int32 + +const ( + AnalysisTriageInfo_NONE AnalysisTriageInfo_AnalysisTriageType = 0 + AnalysisTriageInfo_REGRESSION AnalysisTriageInfo_AnalysisTriageType = 1 + AnalysisTriageInfo_IGNORE AnalysisTriageInfo_AnalysisTriageType = 2 + AnalysisTriageInfo_FALSE_POSITIVE AnalysisTriageInfo_AnalysisTriageType = 3 + AnalysisTriageInfo_UNKNOWN AnalysisTriageInfo_AnalysisTriageType = 4 +) + +var AnalysisTriageInfo_AnalysisTriageType_name = map[int32]string{ + 0: "NONE", + 1: "REGRESSION", + 2: "IGNORE", + 3: "FALSE_POSITIVE", + 4: "UNKNOWN", +} + +var AnalysisTriageInfo_AnalysisTriageType_value = map[string]int32{ + "NONE": 0, + "REGRESSION": 1, + "IGNORE": 2, + "FALSE_POSITIVE": 3, + "UNKNOWN": 4, +} + +func (x AnalysisTriageInfo_AnalysisTriageType) Enum() *AnalysisTriageInfo_AnalysisTriageType { + p := new(AnalysisTriageInfo_AnalysisTriageType) + *p = x + return p +} + +func (x AnalysisTriageInfo_AnalysisTriageType) String() string { + return proto.EnumName(AnalysisTriageInfo_AnalysisTriageType_name, int32(x)) +} + +func (x *AnalysisTriageInfo_AnalysisTriageType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnalysisTriageInfo_AnalysisTriageType_value, data, "AnalysisTriageInfo_AnalysisTriageType") + if err != nil { + return err + } + *x = AnalysisTriageInfo_AnalysisTriageType(value) + return nil +} + +func (AnalysisTriageInfo_AnalysisTriageType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{37, 0} +} + +type AnalysisTriageInfo_EnvironmentType int32 + +const ( + AnalysisTriageInfo_UNSPECIFIED AnalysisTriageInfo_EnvironmentType = 0 + AnalysisTriageInfo_PRESUBMIT AnalysisTriageInfo_EnvironmentType = 1 + AnalysisTriageInfo_POSTSUBMIT AnalysisTriageInfo_EnvironmentType = 2 + AnalysisTriageInfo_PRODUCTION AnalysisTriageInfo_EnvironmentType = 3 +) + +var AnalysisTriageInfo_EnvironmentType_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "PRESUBMIT", + 2: "POSTSUBMIT", + 3: "PRODUCTION", +} + +var AnalysisTriageInfo_EnvironmentType_value = map[string]int32{ + "UNSPECIFIED": 0, + "PRESUBMIT": 1, + "POSTSUBMIT": 2, + "PRODUCTION": 3, +} + +func (x AnalysisTriageInfo_EnvironmentType) Enum() *AnalysisTriageInfo_EnvironmentType { + p := new(AnalysisTriageInfo_EnvironmentType) + *p = x + return p +} + +func (x AnalysisTriageInfo_EnvironmentType) String() string { + return proto.EnumName(AnalysisTriageInfo_EnvironmentType_name, int32(x)) +} + +func (x *AnalysisTriageInfo_EnvironmentType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnalysisTriageInfo_EnvironmentType_value, data, "AnalysisTriageInfo_EnvironmentType") + if err != nil { + return err + } + *x = AnalysisTriageInfo_EnvironmentType(value) + return nil +} + +func (AnalysisTriageInfo_EnvironmentType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{37, 1} +} + +type TestOutput_TestStatus int32 + +const ( + TestOutput_PASS TestOutput_TestStatus = 1 + TestOutput_RATE_FAIL TestOutput_TestStatus = 2 + TestOutput_FATAL_FAIL TestOutput_TestStatus = 3 + TestOutput_ANALYSIS_FAIL TestOutput_TestStatus = 4 + TestOutput_IN_PROGRESS TestOutput_TestStatus = 5 +) + +var TestOutput_TestStatus_name = map[int32]string{ + 1: "PASS", + 2: "RATE_FAIL", + 3: "FATAL_FAIL", + 4: "ANALYSIS_FAIL", + 5: "IN_PROGRESS", +} + +var TestOutput_TestStatus_value = map[string]int32{ + "PASS": 1, + "RATE_FAIL": 2, + "FATAL_FAIL": 3, + "ANALYSIS_FAIL": 4, + "IN_PROGRESS": 5, +} + +func (x TestOutput_TestStatus) Enum() *TestOutput_TestStatus { + p := new(TestOutput_TestStatus) + *p = x + return p +} + +func (x TestOutput_TestStatus) String() string { + return proto.EnumName(TestOutput_TestStatus_name, int32(x)) +} + +func (x *TestOutput_TestStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TestOutput_TestStatus_value, data, "TestOutput_TestStatus") + if err != nil { + return err + } + *x = TestOutput_TestStatus(value) + return nil +} + +func (TestOutput_TestStatus) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{45, 0} +} + +type TestOutput_RetryableFailureType int32 + +const ( + TestOutput_UNKNOWN_OR_UNSET_TYPE TestOutput_RetryableFailureType = 0 + TestOutput_MASTER_RESTART TestOutput_RetryableFailureType = 1 + TestOutput_JOB_MANAGER_RESTART TestOutput_RetryableFailureType = 2 + TestOutput_SAMPLER_RESTART TestOutput_RetryableFailureType = 3 +) + +var TestOutput_RetryableFailureType_name = map[int32]string{ + 0: "UNKNOWN_OR_UNSET_TYPE", + 1: "MASTER_RESTART", + 2: "JOB_MANAGER_RESTART", + 3: "SAMPLER_RESTART", +} + +var TestOutput_RetryableFailureType_value = map[string]int32{ + "UNKNOWN_OR_UNSET_TYPE": 0, + "MASTER_RESTART": 1, + "JOB_MANAGER_RESTART": 2, + "SAMPLER_RESTART": 3, +} + +func (x TestOutput_RetryableFailureType) Enum() *TestOutput_RetryableFailureType { + p := new(TestOutput_RetryableFailureType) + *p = x + return p +} + +func (x TestOutput_RetryableFailureType) String() string { + return proto.EnumName(TestOutput_RetryableFailureType_name, int32(x)) +} + +func (x *TestOutput_RetryableFailureType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TestOutput_RetryableFailureType_value, data, "TestOutput_RetryableFailureType") + if err != nil { + return err + } + *x = TestOutput_RetryableFailureType(value) + return nil +} + +func (TestOutput_RetryableFailureType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{45, 1} +} + +type Status struct { + Code *Status_Code `protobuf:"varint,1,opt,name=code,enum=mako.Status_Code" json:"code,omitempty"` + FailMessage *string `protobuf:"bytes,2,opt,name=fail_message,json=failMessage" json:"fail_message,omitempty"` + Retry *bool `protobuf:"varint,3,opt,name=retry,def=0" json:"retry,omitempty"` + WarningMessages []string `protobuf:"bytes,4,rep,name=warning_messages,json=warningMessages" json:"warning_messages,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Status) Reset() { *m = Status{} } +func (m *Status) String() string { return proto.CompactTextString(m) } +func (*Status) ProtoMessage() {} +func (*Status) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{0} +} + +func (m *Status) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Status.Unmarshal(m, b) +} +func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Status.Marshal(b, m, deterministic) +} +func (m *Status) XXX_Merge(src proto.Message) { + xxx_messageInfo_Status.Merge(m, src) +} +func (m *Status) XXX_Size() int { + return xxx_messageInfo_Status.Size(m) +} +func (m *Status) XXX_DiscardUnknown() { + xxx_messageInfo_Status.DiscardUnknown(m) +} + +var xxx_messageInfo_Status proto.InternalMessageInfo + +const Default_Status_Retry bool = false + +func (m *Status) GetCode() Status_Code { + if m != nil && m.Code != nil { + return *m.Code + } + return Status_SUCCESS +} + +func (m *Status) GetFailMessage() string { + if m != nil && m.FailMessage != nil { + return *m.FailMessage + } + return "" +} + +func (m *Status) GetRetry() bool { + if m != nil && m.Retry != nil { + return *m.Retry + } + return Default_Status_Retry +} + +func (m *Status) GetWarningMessages() []string { + if m != nil { + return m.WarningMessages + } + return nil +} + +type ValueInfo struct { + ValueKey *string `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"` + Label *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"` + Type *ValueInfo_Type `protobuf:"varint,3,opt,name=type,enum=mako.ValueInfo_Type" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValueInfo) Reset() { *m = ValueInfo{} } +func (m *ValueInfo) String() string { return proto.CompactTextString(m) } +func (*ValueInfo) ProtoMessage() {} +func (*ValueInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{1} +} + +func (m *ValueInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ValueInfo.Unmarshal(m, b) +} +func (m *ValueInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ValueInfo.Marshal(b, m, deterministic) +} +func (m *ValueInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValueInfo.Merge(m, src) +} +func (m *ValueInfo) XXX_Size() int { + return xxx_messageInfo_ValueInfo.Size(m) +} +func (m *ValueInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ValueInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ValueInfo proto.InternalMessageInfo + +func (m *ValueInfo) GetValueKey() string { + if m != nil && m.ValueKey != nil { + return *m.ValueKey + } + return "" +} + +func (m *ValueInfo) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" +} + +func (m *ValueInfo) GetType() ValueInfo_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return ValueInfo_NUMERIC +} + +type KeyedValue struct { + ValueKey *string `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"` + Value *float64 `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyedValue) Reset() { *m = KeyedValue{} } +func (m *KeyedValue) String() string { return proto.CompactTextString(m) } +func (*KeyedValue) ProtoMessage() {} +func (*KeyedValue) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{2} +} + +func (m *KeyedValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_KeyedValue.Unmarshal(m, b) +} +func (m *KeyedValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_KeyedValue.Marshal(b, m, deterministic) +} +func (m *KeyedValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyedValue.Merge(m, src) +} +func (m *KeyedValue) XXX_Size() int { + return xxx_messageInfo_KeyedValue.Size(m) +} +func (m *KeyedValue) XXX_DiscardUnknown() { + xxx_messageInfo_KeyedValue.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyedValue proto.InternalMessageInfo + +func (m *KeyedValue) GetValueKey() string { + if m != nil && m.ValueKey != nil { + return *m.ValueKey + } + return "" +} + +func (m *KeyedValue) GetValue() float64 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +type NamedData struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Data *string `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NamedData) Reset() { *m = NamedData{} } +func (m *NamedData) String() string { return proto.CompactTextString(m) } +func (*NamedData) ProtoMessage() {} +func (*NamedData) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{3} +} + +func (m *NamedData) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NamedData.Unmarshal(m, b) +} +func (m *NamedData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NamedData.Marshal(b, m, deterministic) +} +func (m *NamedData) XXX_Merge(src proto.Message) { + xxx_messageInfo_NamedData.Merge(m, src) +} +func (m *NamedData) XXX_Size() int { + return xxx_messageInfo_NamedData.Size(m) +} +func (m *NamedData) XXX_DiscardUnknown() { + xxx_messageInfo_NamedData.DiscardUnknown(m) +} + +var xxx_messageInfo_NamedData proto.InternalMessageInfo + +func (m *NamedData) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *NamedData) GetData() string { + if m != nil && m.Data != nil { + return *m.Data + } + return "" +} + +type Range struct { + Start *float64 `protobuf:"fixed64,1,opt,name=start" json:"start,omitempty"` + End *float64 `protobuf:"fixed64,2,opt,name=end" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Range) Reset() { *m = Range{} } +func (m *Range) String() string { return proto.CompactTextString(m) } +func (*Range) ProtoMessage() {} +func (*Range) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{4} +} + +func (m *Range) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Range.Unmarshal(m, b) +} +func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Range.Marshal(b, m, deterministic) +} +func (m *Range) XXX_Merge(src proto.Message) { + xxx_messageInfo_Range.Merge(m, src) +} +func (m *Range) XXX_Size() int { + return xxx_messageInfo_Range.Size(m) +} +func (m *Range) XXX_DiscardUnknown() { + xxx_messageInfo_Range.DiscardUnknown(m) +} + +var xxx_messageInfo_Range proto.InternalMessageInfo + +func (m *Range) GetStart() float64 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *Range) GetEnd() float64 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +type LabeledRange struct { + Label *string `protobuf:"bytes,1,opt,name=label" json:"label,omitempty"` + Range *Range `protobuf:"bytes,2,opt,name=range" json:"range,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LabeledRange) Reset() { *m = LabeledRange{} } +func (m *LabeledRange) String() string { return proto.CompactTextString(m) } +func (*LabeledRange) ProtoMessage() {} +func (*LabeledRange) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{5} +} + +func (m *LabeledRange) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LabeledRange.Unmarshal(m, b) +} +func (m *LabeledRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LabeledRange.Marshal(b, m, deterministic) +} +func (m *LabeledRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_LabeledRange.Merge(m, src) +} +func (m *LabeledRange) XXX_Size() int { + return xxx_messageInfo_LabeledRange.Size(m) +} +func (m *LabeledRange) XXX_DiscardUnknown() { + xxx_messageInfo_LabeledRange.DiscardUnknown(m) +} + +var xxx_messageInfo_LabeledRange proto.InternalMessageInfo + +func (m *LabeledRange) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" +} + +func (m *LabeledRange) GetRange() *Range { + if m != nil { + return m.Range + } + return nil +} + +type DataFilter struct { + DataType *DataFilter_DataType `protobuf:"varint,1,opt,name=data_type,json=dataType,enum=mako.DataFilter_DataType" json:"data_type,omitempty"` + ValueKey *string `protobuf:"bytes,2,opt,name=value_key,json=valueKey" json:"value_key,omitempty"` + PercentileMilliRank *int32 `protobuf:"varint,3,opt,name=percentile_milli_rank,json=percentileMilliRank" json:"percentile_milli_rank,omitempty"` + IgnoreMissingData *bool `protobuf:"varint,4,opt,name=ignore_missing_data,json=ignoreMissingData,def=1" json:"ignore_missing_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DataFilter) Reset() { *m = DataFilter{} } +func (m *DataFilter) String() string { return proto.CompactTextString(m) } +func (*DataFilter) ProtoMessage() {} +func (*DataFilter) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{6} +} + +func (m *DataFilter) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DataFilter.Unmarshal(m, b) +} +func (m *DataFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DataFilter.Marshal(b, m, deterministic) +} +func (m *DataFilter) XXX_Merge(src proto.Message) { + xxx_messageInfo_DataFilter.Merge(m, src) +} +func (m *DataFilter) XXX_Size() int { + return xxx_messageInfo_DataFilter.Size(m) +} +func (m *DataFilter) XXX_DiscardUnknown() { + xxx_messageInfo_DataFilter.DiscardUnknown(m) +} + +var xxx_messageInfo_DataFilter proto.InternalMessageInfo + +const Default_DataFilter_IgnoreMissingData bool = true + +func (m *DataFilter) GetDataType() DataFilter_DataType { + if m != nil && m.DataType != nil { + return *m.DataType + } + return DataFilter_METRIC_AGGREGATE_COUNT +} + +func (m *DataFilter) GetValueKey() string { + if m != nil && m.ValueKey != nil { + return *m.ValueKey + } + return "" +} + +func (m *DataFilter) GetPercentileMilliRank() int32 { + if m != nil && m.PercentileMilliRank != nil { + return *m.PercentileMilliRank + } + return 0 +} + +func (m *DataFilter) GetIgnoreMissingData() bool { + if m != nil && m.IgnoreMissingData != nil { + return *m.IgnoreMissingData + } + return Default_DataFilter_IgnoreMissingData +} + +type RunBundle struct { + BenchmarkInfo *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"` + RunInfo *RunInfo `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"` + BatchList []*SampleBatch `protobuf:"bytes,3,rep,name=batch_list,json=batchList" json:"batch_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunBundle) Reset() { *m = RunBundle{} } +func (m *RunBundle) String() string { return proto.CompactTextString(m) } +func (*RunBundle) ProtoMessage() {} +func (*RunBundle) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{7} +} + +func (m *RunBundle) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunBundle.Unmarshal(m, b) +} +func (m *RunBundle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunBundle.Marshal(b, m, deterministic) +} +func (m *RunBundle) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunBundle.Merge(m, src) +} +func (m *RunBundle) XXX_Size() int { + return xxx_messageInfo_RunBundle.Size(m) +} +func (m *RunBundle) XXX_DiscardUnknown() { + xxx_messageInfo_RunBundle.DiscardUnknown(m) +} + +var xxx_messageInfo_RunBundle proto.InternalMessageInfo + +func (m *RunBundle) GetBenchmarkInfo() *BenchmarkInfo { + if m != nil { + return m.BenchmarkInfo + } + return nil +} + +func (m *RunBundle) GetRunInfo() *RunInfo { + if m != nil { + return m.RunInfo + } + return nil +} + +func (m *RunBundle) GetBatchList() []*SampleBatch { + if m != nil { + return m.BatchList + } + return nil +} + +type BenchmarkInfo struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + BenchmarkName *string `protobuf:"bytes,2,opt,name=benchmark_name,json=benchmarkName" json:"benchmark_name,omitempty"` + ProjectName *string `protobuf:"bytes,3,opt,name=project_name,json=projectName" json:"project_name,omitempty"` + OwnerList []string `protobuf:"bytes,4,rep,name=owner_list,json=ownerList" json:"owner_list,omitempty"` + InputValueInfo *ValueInfo `protobuf:"bytes,5,opt,name=input_value_info,json=inputValueInfo" json:"input_value_info,omitempty"` + MetricInfoList []*ValueInfo `protobuf:"bytes,6,rep,name=metric_info_list,json=metricInfoList" json:"metric_info_list,omitempty"` + CustomAggregationInfoList []*ValueInfo `protobuf:"bytes,7,rep,name=custom_aggregation_info_list,json=customAggregationInfoList" json:"custom_aggregation_info_list,omitempty"` + Description *string `protobuf:"bytes,8,opt,name=description" json:"description,omitempty"` + PercentileMilliRankList []int32 `protobuf:"varint,9,rep,name=percentile_milli_rank_list,json=percentileMilliRankList" json:"percentile_milli_rank_list,omitempty"` + AuxData []*NamedData `protobuf:"bytes,10,rep,name=aux_data,json=auxData" json:"aux_data,omitempty"` + RetainedRunTag *string `protobuf:"bytes,11,opt,name=retained_run_tag,json=retainedRunTag" json:"retained_run_tag,omitempty"` + BuildIdLabel *string `protobuf:"bytes,12,opt,name=build_id_label,json=buildIdLabel,def=Changelist" json:"build_id_label,omitempty"` + BuildIdUrlFormat *string `protobuf:"bytes,13,opt,name=build_id_url_format,json=buildIdUrlFormat,def=http://cl/%d" json:"build_id_url_format,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BenchmarkInfo) Reset() { *m = BenchmarkInfo{} } +func (m *BenchmarkInfo) String() string { return proto.CompactTextString(m) } +func (*BenchmarkInfo) ProtoMessage() {} +func (*BenchmarkInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{8} +} + +func (m *BenchmarkInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BenchmarkInfo.Unmarshal(m, b) +} +func (m *BenchmarkInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BenchmarkInfo.Marshal(b, m, deterministic) +} +func (m *BenchmarkInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_BenchmarkInfo.Merge(m, src) +} +func (m *BenchmarkInfo) XXX_Size() int { + return xxx_messageInfo_BenchmarkInfo.Size(m) +} +func (m *BenchmarkInfo) XXX_DiscardUnknown() { + xxx_messageInfo_BenchmarkInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_BenchmarkInfo proto.InternalMessageInfo + +const Default_BenchmarkInfo_BuildIdLabel string = "Changelist" +const Default_BenchmarkInfo_BuildIdUrlFormat string = "http://cl/%d" + +func (m *BenchmarkInfo) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *BenchmarkInfo) GetBenchmarkName() string { + if m != nil && m.BenchmarkName != nil { + return *m.BenchmarkName + } + return "" +} + +func (m *BenchmarkInfo) GetProjectName() string { + if m != nil && m.ProjectName != nil { + return *m.ProjectName + } + return "" +} + +func (m *BenchmarkInfo) GetOwnerList() []string { + if m != nil { + return m.OwnerList + } + return nil +} + +func (m *BenchmarkInfo) GetInputValueInfo() *ValueInfo { + if m != nil { + return m.InputValueInfo + } + return nil +} + +func (m *BenchmarkInfo) GetMetricInfoList() []*ValueInfo { + if m != nil { + return m.MetricInfoList + } + return nil +} + +func (m *BenchmarkInfo) GetCustomAggregationInfoList() []*ValueInfo { + if m != nil { + return m.CustomAggregationInfoList + } + return nil +} + +func (m *BenchmarkInfo) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *BenchmarkInfo) GetPercentileMilliRankList() []int32 { + if m != nil { + return m.PercentileMilliRankList + } + return nil +} + +func (m *BenchmarkInfo) GetAuxData() []*NamedData { + if m != nil { + return m.AuxData + } + return nil +} + +func (m *BenchmarkInfo) GetRetainedRunTag() string { + if m != nil && m.RetainedRunTag != nil { + return *m.RetainedRunTag + } + return "" +} + +func (m *BenchmarkInfo) GetBuildIdLabel() string { + if m != nil && m.BuildIdLabel != nil { + return *m.BuildIdLabel + } + return Default_BenchmarkInfo_BuildIdLabel +} + +func (m *BenchmarkInfo) GetBuildIdUrlFormat() string { + if m != nil && m.BuildIdUrlFormat != nil { + return *m.BuildIdUrlFormat + } + return Default_BenchmarkInfo_BuildIdUrlFormat +} + +type RunAnnotation struct { + ValueKey *string `protobuf:"bytes,1,opt,name=value_key,json=valueKey" json:"value_key,omitempty"` + Label *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunAnnotation) Reset() { *m = RunAnnotation{} } +func (m *RunAnnotation) String() string { return proto.CompactTextString(m) } +func (*RunAnnotation) ProtoMessage() {} +func (*RunAnnotation) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{9} +} + +func (m *RunAnnotation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunAnnotation.Unmarshal(m, b) +} +func (m *RunAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunAnnotation.Marshal(b, m, deterministic) +} +func (m *RunAnnotation) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunAnnotation.Merge(m, src) +} +func (m *RunAnnotation) XXX_Size() int { + return xxx_messageInfo_RunAnnotation.Size(m) +} +func (m *RunAnnotation) XXX_DiscardUnknown() { + xxx_messageInfo_RunAnnotation.DiscardUnknown(m) +} + +var xxx_messageInfo_RunAnnotation proto.InternalMessageInfo + +func (m *RunAnnotation) GetValueKey() string { + if m != nil && m.ValueKey != nil { + return *m.ValueKey + } + return "" +} + +func (m *RunAnnotation) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" +} + +func (m *RunAnnotation) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +type RunInfo struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + RunKey *string `protobuf:"bytes,2,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + TimestampMs *float64 `protobuf:"fixed64,3,opt,name=timestamp_ms,json=timestampMs" json:"timestamp_ms,omitempty"` + BuildId *int64 `protobuf:"varint,18,opt,name=build_id,json=buildId" json:"build_id,omitempty"` + DurationTimeMs *float64 `protobuf:"fixed64,4,opt,name=duration_time_ms,json=durationTimeMs,def=0" json:"duration_time_ms,omitempty"` + Tags []string `protobuf:"bytes,5,rep,name=tags" json:"tags,omitempty"` + IgnoreRangeList []*LabeledRange `protobuf:"bytes,6,rep,name=ignore_range_list,json=ignoreRangeList" json:"ignore_range_list,omitempty"` + Aggregate *Aggregate `protobuf:"bytes,7,opt,name=aggregate" json:"aggregate,omitempty"` + BatchKeyList []string `protobuf:"bytes,8,rep,name=batch_key_list,json=batchKeyList" json:"batch_key_list,omitempty"` + Description *string `protobuf:"bytes,9,opt,name=description" json:"description,omitempty"` + AnnotationList []*RunAnnotation `protobuf:"bytes,10,rep,name=annotation_list,json=annotationList" json:"annotation_list,omitempty"` + HoverText *string `protobuf:"bytes,15,opt,name=hover_text,json=hoverText" json:"hover_text,omitempty"` + TestOutput *TestOutput `protobuf:"bytes,12,opt,name=test_output,json=testOutput" json:"test_output,omitempty"` + HyperlinkList []*NamedData `protobuf:"bytes,13,rep,name=hyperlink_list,json=hyperlinkList" json:"hyperlink_list,omitempty"` + AuxData []*NamedData `protobuf:"bytes,16,rep,name=aux_data,json=auxData" json:"aux_data,omitempty"` + TestPassId *string `protobuf:"bytes,17,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"` + TestOptionList []*TestOption `protobuf:"bytes,14,rep,name=test_option_list,json=testOptionList" json:"test_option_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunInfo) Reset() { *m = RunInfo{} } +func (m *RunInfo) String() string { return proto.CompactTextString(m) } +func (*RunInfo) ProtoMessage() {} +func (*RunInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{10} +} + +func (m *RunInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunInfo.Unmarshal(m, b) +} +func (m *RunInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunInfo.Marshal(b, m, deterministic) +} +func (m *RunInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunInfo.Merge(m, src) +} +func (m *RunInfo) XXX_Size() int { + return xxx_messageInfo_RunInfo.Size(m) +} +func (m *RunInfo) XXX_DiscardUnknown() { + xxx_messageInfo_RunInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_RunInfo proto.InternalMessageInfo + +const Default_RunInfo_DurationTimeMs float64 = 0 + +func (m *RunInfo) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *RunInfo) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *RunInfo) GetTimestampMs() float64 { + if m != nil && m.TimestampMs != nil { + return *m.TimestampMs + } + return 0 +} + +func (m *RunInfo) GetBuildId() int64 { + if m != nil && m.BuildId != nil { + return *m.BuildId + } + return 0 +} + +func (m *RunInfo) GetDurationTimeMs() float64 { + if m != nil && m.DurationTimeMs != nil { + return *m.DurationTimeMs + } + return Default_RunInfo_DurationTimeMs +} + +func (m *RunInfo) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *RunInfo) GetIgnoreRangeList() []*LabeledRange { + if m != nil { + return m.IgnoreRangeList + } + return nil +} + +func (m *RunInfo) GetAggregate() *Aggregate { + if m != nil { + return m.Aggregate + } + return nil +} + +func (m *RunInfo) GetBatchKeyList() []string { + if m != nil { + return m.BatchKeyList + } + return nil +} + +func (m *RunInfo) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *RunInfo) GetAnnotationList() []*RunAnnotation { + if m != nil { + return m.AnnotationList + } + return nil +} + +func (m *RunInfo) GetHoverText() string { + if m != nil && m.HoverText != nil { + return *m.HoverText + } + return "" +} + +func (m *RunInfo) GetTestOutput() *TestOutput { + if m != nil { + return m.TestOutput + } + return nil +} + +func (m *RunInfo) GetHyperlinkList() []*NamedData { + if m != nil { + return m.HyperlinkList + } + return nil +} + +func (m *RunInfo) GetAuxData() []*NamedData { + if m != nil { + return m.AuxData + } + return nil +} + +func (m *RunInfo) GetTestPassId() string { + if m != nil && m.TestPassId != nil { + return *m.TestPassId + } + return "" +} + +func (m *RunInfo) GetTestOptionList() []*TestOption { + if m != nil { + return m.TestOptionList + } + return nil +} + +type SamplePoint struct { + InputValue *float64 `protobuf:"fixed64,1,opt,name=input_value,json=inputValue" json:"input_value,omitempty"` + MetricValueList []*KeyedValue `protobuf:"bytes,2,rep,name=metric_value_list,json=metricValueList" json:"metric_value_list,omitempty"` + SampleAnnotationsList []*SampleAnnotation `protobuf:"bytes,3,rep,name=sample_annotations_list,json=sampleAnnotationsList" json:"sample_annotations_list,omitempty"` + AuxData map[string][]byte `protobuf:"bytes,4,rep,name=aux_data,json=auxData" json:"aux_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SamplePoint) Reset() { *m = SamplePoint{} } +func (m *SamplePoint) String() string { return proto.CompactTextString(m) } +func (*SamplePoint) ProtoMessage() {} +func (*SamplePoint) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{11} +} + +func (m *SamplePoint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SamplePoint.Unmarshal(m, b) +} +func (m *SamplePoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SamplePoint.Marshal(b, m, deterministic) +} +func (m *SamplePoint) XXX_Merge(src proto.Message) { + xxx_messageInfo_SamplePoint.Merge(m, src) +} +func (m *SamplePoint) XXX_Size() int { + return xxx_messageInfo_SamplePoint.Size(m) +} +func (m *SamplePoint) XXX_DiscardUnknown() { + xxx_messageInfo_SamplePoint.DiscardUnknown(m) +} + +var xxx_messageInfo_SamplePoint proto.InternalMessageInfo + +func (m *SamplePoint) GetInputValue() float64 { + if m != nil && m.InputValue != nil { + return *m.InputValue + } + return 0 +} + +func (m *SamplePoint) GetMetricValueList() []*KeyedValue { + if m != nil { + return m.MetricValueList + } + return nil +} + +func (m *SamplePoint) GetSampleAnnotationsList() []*SampleAnnotation { + if m != nil { + return m.SampleAnnotationsList + } + return nil +} + +func (m *SamplePoint) GetAuxData() map[string][]byte { + if m != nil { + return m.AuxData + } + return nil +} + +type SampleAnnotation struct { + // Types that are valid to be assigned to Annotation: + // *SampleAnnotation_Text + // *SampleAnnotation_Hyperlink + Annotation isSampleAnnotation_Annotation `protobuf_oneof:"annotation"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleAnnotation) Reset() { *m = SampleAnnotation{} } +func (m *SampleAnnotation) String() string { return proto.CompactTextString(m) } +func (*SampleAnnotation) ProtoMessage() {} +func (*SampleAnnotation) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{12} +} + +func (m *SampleAnnotation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleAnnotation.Unmarshal(m, b) +} +func (m *SampleAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleAnnotation.Marshal(b, m, deterministic) +} +func (m *SampleAnnotation) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleAnnotation.Merge(m, src) +} +func (m *SampleAnnotation) XXX_Size() int { + return xxx_messageInfo_SampleAnnotation.Size(m) +} +func (m *SampleAnnotation) XXX_DiscardUnknown() { + xxx_messageInfo_SampleAnnotation.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleAnnotation proto.InternalMessageInfo + +type isSampleAnnotation_Annotation interface { + isSampleAnnotation_Annotation() +} + +type SampleAnnotation_Text struct { + Text string `protobuf:"bytes,1,opt,name=text,oneof"` +} + +type SampleAnnotation_Hyperlink struct { + Hyperlink *NamedData `protobuf:"bytes,2,opt,name=hyperlink,oneof"` +} + +func (*SampleAnnotation_Text) isSampleAnnotation_Annotation() {} + +func (*SampleAnnotation_Hyperlink) isSampleAnnotation_Annotation() {} + +func (m *SampleAnnotation) GetAnnotation() isSampleAnnotation_Annotation { + if m != nil { + return m.Annotation + } + return nil +} + +func (m *SampleAnnotation) GetText() string { + if x, ok := m.GetAnnotation().(*SampleAnnotation_Text); ok { + return x.Text + } + return "" +} + +func (m *SampleAnnotation) GetHyperlink() *NamedData { + if x, ok := m.GetAnnotation().(*SampleAnnotation_Hyperlink); ok { + return x.Hyperlink + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*SampleAnnotation) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*SampleAnnotation_Text)(nil), + (*SampleAnnotation_Hyperlink)(nil), + } +} + +type SampleError struct { + InputValue *float64 `protobuf:"fixed64,1,opt,name=input_value,json=inputValue" json:"input_value,omitempty"` + SamplerName *string `protobuf:"bytes,2,opt,name=sampler_name,json=samplerName" json:"sampler_name,omitempty"` + ErrorMessage *string `protobuf:"bytes,3,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleError) Reset() { *m = SampleError{} } +func (m *SampleError) String() string { return proto.CompactTextString(m) } +func (*SampleError) ProtoMessage() {} +func (*SampleError) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{13} +} + +func (m *SampleError) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleError.Unmarshal(m, b) +} +func (m *SampleError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleError.Marshal(b, m, deterministic) +} +func (m *SampleError) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleError.Merge(m, src) +} +func (m *SampleError) XXX_Size() int { + return xxx_messageInfo_SampleError.Size(m) +} +func (m *SampleError) XXX_DiscardUnknown() { + xxx_messageInfo_SampleError.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleError proto.InternalMessageInfo + +func (m *SampleError) GetInputValue() float64 { + if m != nil && m.InputValue != nil { + return *m.InputValue + } + return 0 +} + +func (m *SampleError) GetSamplerName() string { + if m != nil && m.SamplerName != nil { + return *m.SamplerName + } + return "" +} + +func (m *SampleError) GetErrorMessage() string { + if m != nil && m.ErrorMessage != nil { + return *m.ErrorMessage + } + return "" +} + +type SampleBatch struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + RunKey *string `protobuf:"bytes,2,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + BatchKey *string `protobuf:"bytes,3,opt,name=batch_key,json=batchKey" json:"batch_key,omitempty"` + SamplePointList []*SamplePoint `protobuf:"bytes,4,rep,name=sample_point_list,json=samplePointList" json:"sample_point_list,omitempty"` + SampleErrorList []*SampleError `protobuf:"bytes,5,rep,name=sample_error_list,json=sampleErrorList" json:"sample_error_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleBatch) Reset() { *m = SampleBatch{} } +func (m *SampleBatch) String() string { return proto.CompactTextString(m) } +func (*SampleBatch) ProtoMessage() {} +func (*SampleBatch) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{14} +} + +func (m *SampleBatch) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleBatch.Unmarshal(m, b) +} +func (m *SampleBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleBatch.Marshal(b, m, deterministic) +} +func (m *SampleBatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleBatch.Merge(m, src) +} +func (m *SampleBatch) XXX_Size() int { + return xxx_messageInfo_SampleBatch.Size(m) +} +func (m *SampleBatch) XXX_DiscardUnknown() { + xxx_messageInfo_SampleBatch.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleBatch proto.InternalMessageInfo + +func (m *SampleBatch) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *SampleBatch) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *SampleBatch) GetBatchKey() string { + if m != nil && m.BatchKey != nil { + return *m.BatchKey + } + return "" +} + +func (m *SampleBatch) GetSamplePointList() []*SamplePoint { + if m != nil { + return m.SamplePointList + } + return nil +} + +func (m *SampleBatch) GetSampleErrorList() []*SampleError { + if m != nil { + return m.SampleErrorList + } + return nil +} + +type MetricAggregate struct { + MetricKey *string `protobuf:"bytes,1,opt,name=metric_key,json=metricKey" json:"metric_key,omitempty"` + Min *float64 `protobuf:"fixed64,2,opt,name=min" json:"min,omitempty"` + Max *float64 `protobuf:"fixed64,3,opt,name=max" json:"max,omitempty"` + Mean *float64 `protobuf:"fixed64,4,opt,name=mean" json:"mean,omitempty"` + Median *float64 `protobuf:"fixed64,5,opt,name=median" json:"median,omitempty"` + StandardDeviation *float64 `protobuf:"fixed64,6,opt,name=standard_deviation,json=standardDeviation" json:"standard_deviation,omitempty"` + MedianAbsoluteDeviation *float64 `protobuf:"fixed64,9,opt,name=median_absolute_deviation,json=medianAbsoluteDeviation" json:"median_absolute_deviation,omitempty"` + PercentileList []float64 `protobuf:"fixed64,7,rep,name=percentile_list,json=percentileList" json:"percentile_list,omitempty"` + Count *int64 `protobuf:"varint,8,opt,name=count" json:"count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MetricAggregate) Reset() { *m = MetricAggregate{} } +func (m *MetricAggregate) String() string { return proto.CompactTextString(m) } +func (*MetricAggregate) ProtoMessage() {} +func (*MetricAggregate) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{15} +} + +func (m *MetricAggregate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MetricAggregate.Unmarshal(m, b) +} +func (m *MetricAggregate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MetricAggregate.Marshal(b, m, deterministic) +} +func (m *MetricAggregate) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetricAggregate.Merge(m, src) +} +func (m *MetricAggregate) XXX_Size() int { + return xxx_messageInfo_MetricAggregate.Size(m) +} +func (m *MetricAggregate) XXX_DiscardUnknown() { + xxx_messageInfo_MetricAggregate.DiscardUnknown(m) +} + +var xxx_messageInfo_MetricAggregate proto.InternalMessageInfo + +func (m *MetricAggregate) GetMetricKey() string { + if m != nil && m.MetricKey != nil { + return *m.MetricKey + } + return "" +} + +func (m *MetricAggregate) GetMin() float64 { + if m != nil && m.Min != nil { + return *m.Min + } + return 0 +} + +func (m *MetricAggregate) GetMax() float64 { + if m != nil && m.Max != nil { + return *m.Max + } + return 0 +} + +func (m *MetricAggregate) GetMean() float64 { + if m != nil && m.Mean != nil { + return *m.Mean + } + return 0 +} + +func (m *MetricAggregate) GetMedian() float64 { + if m != nil && m.Median != nil { + return *m.Median + } + return 0 +} + +func (m *MetricAggregate) GetStandardDeviation() float64 { + if m != nil && m.StandardDeviation != nil { + return *m.StandardDeviation + } + return 0 +} + +func (m *MetricAggregate) GetMedianAbsoluteDeviation() float64 { + if m != nil && m.MedianAbsoluteDeviation != nil { + return *m.MedianAbsoluteDeviation + } + return 0 +} + +func (m *MetricAggregate) GetPercentileList() []float64 { + if m != nil { + return m.PercentileList + } + return nil +} + +func (m *MetricAggregate) GetCount() int64 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type RunAggregate struct { + UsableSampleCount *int64 `protobuf:"varint,1,opt,name=usable_sample_count,json=usableSampleCount" json:"usable_sample_count,omitempty"` + IgnoreSampleCount *int64 `protobuf:"varint,2,opt,name=ignore_sample_count,json=ignoreSampleCount,def=0" json:"ignore_sample_count,omitempty"` + ErrorSampleCount *int64 `protobuf:"varint,3,opt,name=error_sample_count,json=errorSampleCount,def=0" json:"error_sample_count,omitempty"` + BenchmarkScore *int32 `protobuf:"varint,4,opt,name=benchmark_score,json=benchmarkScore,def=0" json:"benchmark_score,omitempty"` + CustomAggregateList []*KeyedValue `protobuf:"bytes,5,rep,name=custom_aggregate_list,json=customAggregateList" json:"custom_aggregate_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunAggregate) Reset() { *m = RunAggregate{} } +func (m *RunAggregate) String() string { return proto.CompactTextString(m) } +func (*RunAggregate) ProtoMessage() {} +func (*RunAggregate) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{16} +} + +func (m *RunAggregate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunAggregate.Unmarshal(m, b) +} +func (m *RunAggregate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunAggregate.Marshal(b, m, deterministic) +} +func (m *RunAggregate) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunAggregate.Merge(m, src) +} +func (m *RunAggregate) XXX_Size() int { + return xxx_messageInfo_RunAggregate.Size(m) +} +func (m *RunAggregate) XXX_DiscardUnknown() { + xxx_messageInfo_RunAggregate.DiscardUnknown(m) +} + +var xxx_messageInfo_RunAggregate proto.InternalMessageInfo + +const Default_RunAggregate_IgnoreSampleCount int64 = 0 +const Default_RunAggregate_ErrorSampleCount int64 = 0 +const Default_RunAggregate_BenchmarkScore int32 = 0 + +func (m *RunAggregate) GetUsableSampleCount() int64 { + if m != nil && m.UsableSampleCount != nil { + return *m.UsableSampleCount + } + return 0 +} + +func (m *RunAggregate) GetIgnoreSampleCount() int64 { + if m != nil && m.IgnoreSampleCount != nil { + return *m.IgnoreSampleCount + } + return Default_RunAggregate_IgnoreSampleCount +} + +func (m *RunAggregate) GetErrorSampleCount() int64 { + if m != nil && m.ErrorSampleCount != nil { + return *m.ErrorSampleCount + } + return Default_RunAggregate_ErrorSampleCount +} + +func (m *RunAggregate) GetBenchmarkScore() int32 { + if m != nil && m.BenchmarkScore != nil { + return *m.BenchmarkScore + } + return Default_RunAggregate_BenchmarkScore +} + +func (m *RunAggregate) GetCustomAggregateList() []*KeyedValue { + if m != nil { + return m.CustomAggregateList + } + return nil +} + +type Aggregate struct { + MetricAggregateList []*MetricAggregate `protobuf:"bytes,1,rep,name=metric_aggregate_list,json=metricAggregateList" json:"metric_aggregate_list,omitempty"` + RunAggregate *RunAggregate `protobuf:"bytes,2,opt,name=run_aggregate,json=runAggregate" json:"run_aggregate,omitempty"` + PercentileMilliRankList []int32 `protobuf:"varint,3,rep,name=percentile_milli_rank_list,json=percentileMilliRankList" json:"percentile_milli_rank_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Aggregate) Reset() { *m = Aggregate{} } +func (m *Aggregate) String() string { return proto.CompactTextString(m) } +func (*Aggregate) ProtoMessage() {} +func (*Aggregate) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{17} +} + +func (m *Aggregate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Aggregate.Unmarshal(m, b) +} +func (m *Aggregate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Aggregate.Marshal(b, m, deterministic) +} +func (m *Aggregate) XXX_Merge(src proto.Message) { + xxx_messageInfo_Aggregate.Merge(m, src) +} +func (m *Aggregate) XXX_Size() int { + return xxx_messageInfo_Aggregate.Size(m) +} +func (m *Aggregate) XXX_DiscardUnknown() { + xxx_messageInfo_Aggregate.DiscardUnknown(m) +} + +var xxx_messageInfo_Aggregate proto.InternalMessageInfo + +func (m *Aggregate) GetMetricAggregateList() []*MetricAggregate { + if m != nil { + return m.MetricAggregateList + } + return nil +} + +func (m *Aggregate) GetRunAggregate() *RunAggregate { + if m != nil { + return m.RunAggregate + } + return nil +} + +func (m *Aggregate) GetPercentileMilliRankList() []int32 { + if m != nil { + return m.PercentileMilliRankList + } + return nil +} + +type BenchmarkInfoQuery struct { + Cursor *string `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"` + Limit *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` + BenchmarkKey *string `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + BenchmarkName *string `protobuf:"bytes,4,opt,name=benchmark_name,json=benchmarkName" json:"benchmark_name,omitempty"` + ProjectName *string `protobuf:"bytes,5,opt,name=project_name,json=projectName" json:"project_name,omitempty"` + Owner *string `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BenchmarkInfoQuery) Reset() { *m = BenchmarkInfoQuery{} } +func (m *BenchmarkInfoQuery) String() string { return proto.CompactTextString(m) } +func (*BenchmarkInfoQuery) ProtoMessage() {} +func (*BenchmarkInfoQuery) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{18} +} + +func (m *BenchmarkInfoQuery) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BenchmarkInfoQuery.Unmarshal(m, b) +} +func (m *BenchmarkInfoQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BenchmarkInfoQuery.Marshal(b, m, deterministic) +} +func (m *BenchmarkInfoQuery) XXX_Merge(src proto.Message) { + xxx_messageInfo_BenchmarkInfoQuery.Merge(m, src) +} +func (m *BenchmarkInfoQuery) XXX_Size() int { + return xxx_messageInfo_BenchmarkInfoQuery.Size(m) +} +func (m *BenchmarkInfoQuery) XXX_DiscardUnknown() { + xxx_messageInfo_BenchmarkInfoQuery.DiscardUnknown(m) +} + +var xxx_messageInfo_BenchmarkInfoQuery proto.InternalMessageInfo + +func (m *BenchmarkInfoQuery) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *BenchmarkInfoQuery) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *BenchmarkInfoQuery) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *BenchmarkInfoQuery) GetBenchmarkName() string { + if m != nil && m.BenchmarkName != nil { + return *m.BenchmarkName + } + return "" +} + +func (m *BenchmarkInfoQuery) GetProjectName() string { + if m != nil && m.ProjectName != nil { + return *m.ProjectName + } + return "" +} + +func (m *BenchmarkInfoQuery) GetOwner() string { + if m != nil && m.Owner != nil { + return *m.Owner + } + return "" +} + +type BenchmarkInfoQueryResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Cursor *string `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"` + BenchmarkInfoList []*BenchmarkInfo `protobuf:"bytes,4,rep,name=benchmark_info_list,json=benchmarkInfoList" json:"benchmark_info_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BenchmarkInfoQueryResponse) Reset() { *m = BenchmarkInfoQueryResponse{} } +func (m *BenchmarkInfoQueryResponse) String() string { return proto.CompactTextString(m) } +func (*BenchmarkInfoQueryResponse) ProtoMessage() {} +func (*BenchmarkInfoQueryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{19} +} + +func (m *BenchmarkInfoQueryResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BenchmarkInfoQueryResponse.Unmarshal(m, b) +} +func (m *BenchmarkInfoQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BenchmarkInfoQueryResponse.Marshal(b, m, deterministic) +} +func (m *BenchmarkInfoQueryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BenchmarkInfoQueryResponse.Merge(m, src) +} +func (m *BenchmarkInfoQueryResponse) XXX_Size() int { + return xxx_messageInfo_BenchmarkInfoQueryResponse.Size(m) +} +func (m *BenchmarkInfoQueryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BenchmarkInfoQueryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BenchmarkInfoQueryResponse proto.InternalMessageInfo + +func (m *BenchmarkInfoQueryResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *BenchmarkInfoQueryResponse) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *BenchmarkInfoQueryResponse) GetBenchmarkInfoList() []*BenchmarkInfo { + if m != nil { + return m.BenchmarkInfoList + } + return nil +} + +type RunInfoQuery struct { + Cursor *string `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"` + Limit *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` + BenchmarkKey *string `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + RunKey *string `protobuf:"bytes,4,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + TestPassId *string `protobuf:"bytes,11,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"` + RunOrder *RunOrder `protobuf:"varint,8,opt,name=run_order,json=runOrder,enum=mako.RunOrder,def=1" json:"run_order,omitempty"` + MinTimestampMs *float64 `protobuf:"fixed64,5,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"` + MaxTimestampMs *float64 `protobuf:"fixed64,6,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"` + MinBuildId *int64 `protobuf:"varint,9,opt,name=min_build_id,json=minBuildId" json:"min_build_id,omitempty"` + MaxBuildId *int64 `protobuf:"varint,10,opt,name=max_build_id,json=maxBuildId" json:"max_build_id,omitempty"` + Tags []string `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"` + Fields []string `protobuf:"bytes,12,rep,name=fields" json:"fields,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunInfoQuery) Reset() { *m = RunInfoQuery{} } +func (m *RunInfoQuery) String() string { return proto.CompactTextString(m) } +func (*RunInfoQuery) ProtoMessage() {} +func (*RunInfoQuery) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{20} +} + +func (m *RunInfoQuery) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunInfoQuery.Unmarshal(m, b) +} +func (m *RunInfoQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunInfoQuery.Marshal(b, m, deterministic) +} +func (m *RunInfoQuery) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunInfoQuery.Merge(m, src) +} +func (m *RunInfoQuery) XXX_Size() int { + return xxx_messageInfo_RunInfoQuery.Size(m) +} +func (m *RunInfoQuery) XXX_DiscardUnknown() { + xxx_messageInfo_RunInfoQuery.DiscardUnknown(m) +} + +var xxx_messageInfo_RunInfoQuery proto.InternalMessageInfo + +const Default_RunInfoQuery_RunOrder RunOrder = RunOrder_TIMESTAMP + +func (m *RunInfoQuery) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *RunInfoQuery) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *RunInfoQuery) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *RunInfoQuery) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *RunInfoQuery) GetTestPassId() string { + if m != nil && m.TestPassId != nil { + return *m.TestPassId + } + return "" +} + +func (m *RunInfoQuery) GetRunOrder() RunOrder { + if m != nil && m.RunOrder != nil { + return *m.RunOrder + } + return Default_RunInfoQuery_RunOrder +} + +func (m *RunInfoQuery) GetMinTimestampMs() float64 { + if m != nil && m.MinTimestampMs != nil { + return *m.MinTimestampMs + } + return 0 +} + +func (m *RunInfoQuery) GetMaxTimestampMs() float64 { + if m != nil && m.MaxTimestampMs != nil { + return *m.MaxTimestampMs + } + return 0 +} + +func (m *RunInfoQuery) GetMinBuildId() int64 { + if m != nil && m.MinBuildId != nil { + return *m.MinBuildId + } + return 0 +} + +func (m *RunInfoQuery) GetMaxBuildId() int64 { + if m != nil && m.MaxBuildId != nil { + return *m.MaxBuildId + } + return 0 +} + +func (m *RunInfoQuery) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *RunInfoQuery) GetFields() []string { + if m != nil { + return m.Fields + } + return nil +} + +type RunInfoQueryResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Cursor *string `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"` + RunInfoList []*RunInfo `protobuf:"bytes,4,rep,name=run_info_list,json=runInfoList" json:"run_info_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunInfoQueryResponse) Reset() { *m = RunInfoQueryResponse{} } +func (m *RunInfoQueryResponse) String() string { return proto.CompactTextString(m) } +func (*RunInfoQueryResponse) ProtoMessage() {} +func (*RunInfoQueryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{21} +} + +func (m *RunInfoQueryResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RunInfoQueryResponse.Unmarshal(m, b) +} +func (m *RunInfoQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RunInfoQueryResponse.Marshal(b, m, deterministic) +} +func (m *RunInfoQueryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunInfoQueryResponse.Merge(m, src) +} +func (m *RunInfoQueryResponse) XXX_Size() int { + return xxx_messageInfo_RunInfoQueryResponse.Size(m) +} +func (m *RunInfoQueryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RunInfoQueryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RunInfoQueryResponse proto.InternalMessageInfo + +func (m *RunInfoQueryResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *RunInfoQueryResponse) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *RunInfoQueryResponse) GetRunInfoList() []*RunInfo { + if m != nil { + return m.RunInfoList + } + return nil +} + +type SampleBatchQuery struct { + Cursor *string `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"` + Limit *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` + BenchmarkKey *string `protobuf:"bytes,3,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + RunKey *string `protobuf:"bytes,4,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + BatchKey *string `protobuf:"bytes,5,opt,name=batch_key,json=batchKey" json:"batch_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleBatchQuery) Reset() { *m = SampleBatchQuery{} } +func (m *SampleBatchQuery) String() string { return proto.CompactTextString(m) } +func (*SampleBatchQuery) ProtoMessage() {} +func (*SampleBatchQuery) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{22} +} + +func (m *SampleBatchQuery) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleBatchQuery.Unmarshal(m, b) +} +func (m *SampleBatchQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleBatchQuery.Marshal(b, m, deterministic) +} +func (m *SampleBatchQuery) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleBatchQuery.Merge(m, src) +} +func (m *SampleBatchQuery) XXX_Size() int { + return xxx_messageInfo_SampleBatchQuery.Size(m) +} +func (m *SampleBatchQuery) XXX_DiscardUnknown() { + xxx_messageInfo_SampleBatchQuery.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleBatchQuery proto.InternalMessageInfo + +func (m *SampleBatchQuery) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *SampleBatchQuery) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *SampleBatchQuery) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *SampleBatchQuery) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *SampleBatchQuery) GetBatchKey() string { + if m != nil && m.BatchKey != nil { + return *m.BatchKey + } + return "" +} + +type SampleBatchQueryResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Cursor *string `protobuf:"bytes,2,opt,name=cursor" json:"cursor,omitempty"` + SampleBatchList []*SampleBatch `protobuf:"bytes,4,rep,name=sample_batch_list,json=sampleBatchList" json:"sample_batch_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleBatchQueryResponse) Reset() { *m = SampleBatchQueryResponse{} } +func (m *SampleBatchQueryResponse) String() string { return proto.CompactTextString(m) } +func (*SampleBatchQueryResponse) ProtoMessage() {} +func (*SampleBatchQueryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{23} +} + +func (m *SampleBatchQueryResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleBatchQueryResponse.Unmarshal(m, b) +} +func (m *SampleBatchQueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleBatchQueryResponse.Marshal(b, m, deterministic) +} +func (m *SampleBatchQueryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleBatchQueryResponse.Merge(m, src) +} +func (m *SampleBatchQueryResponse) XXX_Size() int { + return xxx_messageInfo_SampleBatchQueryResponse.Size(m) +} +func (m *SampleBatchQueryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SampleBatchQueryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleBatchQueryResponse proto.InternalMessageInfo + +func (m *SampleBatchQueryResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *SampleBatchQueryResponse) GetCursor() string { + if m != nil && m.Cursor != nil { + return *m.Cursor + } + return "" +} + +func (m *SampleBatchQueryResponse) GetSampleBatchList() []*SampleBatch { + if m != nil { + return m.SampleBatchList + } + return nil +} + +type CreationResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Key *string `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreationResponse) Reset() { *m = CreationResponse{} } +func (m *CreationResponse) String() string { return proto.CompactTextString(m) } +func (*CreationResponse) ProtoMessage() {} +func (*CreationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{24} +} + +func (m *CreationResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreationResponse.Unmarshal(m, b) +} +func (m *CreationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreationResponse.Marshal(b, m, deterministic) +} +func (m *CreationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreationResponse.Merge(m, src) +} +func (m *CreationResponse) XXX_Size() int { + return xxx_messageInfo_CreationResponse.Size(m) +} +func (m *CreationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CreationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CreationResponse proto.InternalMessageInfo + +func (m *CreationResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *CreationResponse) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +type ModificationResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Count *int64 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ModificationResponse) Reset() { *m = ModificationResponse{} } +func (m *ModificationResponse) String() string { return proto.CompactTextString(m) } +func (*ModificationResponse) ProtoMessage() {} +func (*ModificationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{25} +} + +func (m *ModificationResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ModificationResponse.Unmarshal(m, b) +} +func (m *ModificationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ModificationResponse.Marshal(b, m, deterministic) +} +func (m *ModificationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModificationResponse.Merge(m, src) +} +func (m *ModificationResponse) XXX_Size() int { + return xxx_messageInfo_ModificationResponse.Size(m) +} +func (m *ModificationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ModificationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ModificationResponse proto.InternalMessageInfo + +func (m *ModificationResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *ModificationResponse) GetCount() int64 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type CountResponse struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Count *int64 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CountResponse) Reset() { *m = CountResponse{} } +func (m *CountResponse) String() string { return proto.CompactTextString(m) } +func (*CountResponse) ProtoMessage() {} +func (*CountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{26} +} + +func (m *CountResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CountResponse.Unmarshal(m, b) +} +func (m *CountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CountResponse.Marshal(b, m, deterministic) +} +func (m *CountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CountResponse.Merge(m, src) +} +func (m *CountResponse) XXX_Size() int { + return xxx_messageInfo_CountResponse.Size(m) +} +func (m *CountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CountResponse proto.InternalMessageInfo + +func (m *CountResponse) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *CountResponse) GetCount() int64 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type SecondaryStorageWriteInput struct { + Bundle *RunBundle `protobuf:"bytes,1,opt,name=bundle" json:"bundle,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SecondaryStorageWriteInput) Reset() { *m = SecondaryStorageWriteInput{} } +func (m *SecondaryStorageWriteInput) String() string { return proto.CompactTextString(m) } +func (*SecondaryStorageWriteInput) ProtoMessage() {} +func (*SecondaryStorageWriteInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{27} +} + +func (m *SecondaryStorageWriteInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SecondaryStorageWriteInput.Unmarshal(m, b) +} +func (m *SecondaryStorageWriteInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SecondaryStorageWriteInput.Marshal(b, m, deterministic) +} +func (m *SecondaryStorageWriteInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_SecondaryStorageWriteInput.Merge(m, src) +} +func (m *SecondaryStorageWriteInput) XXX_Size() int { + return xxx_messageInfo_SecondaryStorageWriteInput.Size(m) +} +func (m *SecondaryStorageWriteInput) XXX_DiscardUnknown() { + xxx_messageInfo_SecondaryStorageWriteInput.DiscardUnknown(m) +} + +var xxx_messageInfo_SecondaryStorageWriteInput proto.InternalMessageInfo + +func (m *SecondaryStorageWriteInput) GetBundle() *RunBundle { + if m != nil { + return m.Bundle + } + return nil +} + +type SecondaryStorageWriteOutput struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Links []*NamedData `protobuf:"bytes,2,rep,name=links" json:"links,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SecondaryStorageWriteOutput) Reset() { *m = SecondaryStorageWriteOutput{} } +func (m *SecondaryStorageWriteOutput) String() string { return proto.CompactTextString(m) } +func (*SecondaryStorageWriteOutput) ProtoMessage() {} +func (*SecondaryStorageWriteOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{28} +} + +func (m *SecondaryStorageWriteOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SecondaryStorageWriteOutput.Unmarshal(m, b) +} +func (m *SecondaryStorageWriteOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SecondaryStorageWriteOutput.Marshal(b, m, deterministic) +} +func (m *SecondaryStorageWriteOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_SecondaryStorageWriteOutput.Merge(m, src) +} +func (m *SecondaryStorageWriteOutput) XXX_Size() int { + return xxx_messageInfo_SecondaryStorageWriteOutput.Size(m) +} +func (m *SecondaryStorageWriteOutput) XXX_DiscardUnknown() { + xxx_messageInfo_SecondaryStorageWriteOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_SecondaryStorageWriteOutput proto.InternalMessageInfo + +func (m *SecondaryStorageWriteOutput) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *SecondaryStorageWriteOutput) GetLinks() []*NamedData { + if m != nil { + return m.Links + } + return nil +} + +type AggregatorInput struct { + BenchmarkInfo *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"` + RunInfo *RunInfo `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"` + SampleFileList []*SampleFile `protobuf:"bytes,3,rep,name=sample_file_list,json=sampleFileList" json:"sample_file_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AggregatorInput) Reset() { *m = AggregatorInput{} } +func (m *AggregatorInput) String() string { return proto.CompactTextString(m) } +func (*AggregatorInput) ProtoMessage() {} +func (*AggregatorInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{29} +} + +func (m *AggregatorInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AggregatorInput.Unmarshal(m, b) +} +func (m *AggregatorInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AggregatorInput.Marshal(b, m, deterministic) +} +func (m *AggregatorInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AggregatorInput.Merge(m, src) +} +func (m *AggregatorInput) XXX_Size() int { + return xxx_messageInfo_AggregatorInput.Size(m) +} +func (m *AggregatorInput) XXX_DiscardUnknown() { + xxx_messageInfo_AggregatorInput.DiscardUnknown(m) +} + +var xxx_messageInfo_AggregatorInput proto.InternalMessageInfo + +func (m *AggregatorInput) GetBenchmarkInfo() *BenchmarkInfo { + if m != nil { + return m.BenchmarkInfo + } + return nil +} + +func (m *AggregatorInput) GetRunInfo() *RunInfo { + if m != nil { + return m.RunInfo + } + return nil +} + +func (m *AggregatorInput) GetSampleFileList() []*SampleFile { + if m != nil { + return m.SampleFileList + } + return nil +} + +type AggregatorOutput struct { + Aggregate *Aggregate `protobuf:"bytes,1,opt,name=aggregate" json:"aggregate,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AggregatorOutput) Reset() { *m = AggregatorOutput{} } +func (m *AggregatorOutput) String() string { return proto.CompactTextString(m) } +func (*AggregatorOutput) ProtoMessage() {} +func (*AggregatorOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{30} +} + +func (m *AggregatorOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AggregatorOutput.Unmarshal(m, b) +} +func (m *AggregatorOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AggregatorOutput.Marshal(b, m, deterministic) +} +func (m *AggregatorOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AggregatorOutput.Merge(m, src) +} +func (m *AggregatorOutput) XXX_Size() int { + return xxx_messageInfo_AggregatorOutput.Size(m) +} +func (m *AggregatorOutput) XXX_DiscardUnknown() { + xxx_messageInfo_AggregatorOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_AggregatorOutput proto.InternalMessageInfo + +func (m *AggregatorOutput) GetAggregate() *Aggregate { + if m != nil { + return m.Aggregate + } + return nil +} + +type DownsamplerInput struct { + RunInfo *RunInfo `protobuf:"bytes,1,opt,name=run_info,json=runInfo" json:"run_info,omitempty"` + SampleFileList []*SampleFile `protobuf:"bytes,2,rep,name=sample_file_list,json=sampleFileList" json:"sample_file_list,omitempty"` + MetricValueCountMax *int64 `protobuf:"varint,6,opt,name=metric_value_count_max,json=metricValueCountMax" json:"metric_value_count_max,omitempty"` + SampleErrorCountMax *int64 `protobuf:"varint,4,opt,name=sample_error_count_max,json=sampleErrorCountMax" json:"sample_error_count_max,omitempty"` + BatchSizeMax *int64 `protobuf:"varint,5,opt,name=batch_size_max,json=batchSizeMax" json:"batch_size_max,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DownsamplerInput) Reset() { *m = DownsamplerInput{} } +func (m *DownsamplerInput) String() string { return proto.CompactTextString(m) } +func (*DownsamplerInput) ProtoMessage() {} +func (*DownsamplerInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{31} +} + +func (m *DownsamplerInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DownsamplerInput.Unmarshal(m, b) +} +func (m *DownsamplerInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DownsamplerInput.Marshal(b, m, deterministic) +} +func (m *DownsamplerInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DownsamplerInput.Merge(m, src) +} +func (m *DownsamplerInput) XXX_Size() int { + return xxx_messageInfo_DownsamplerInput.Size(m) +} +func (m *DownsamplerInput) XXX_DiscardUnknown() { + xxx_messageInfo_DownsamplerInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DownsamplerInput proto.InternalMessageInfo + +func (m *DownsamplerInput) GetRunInfo() *RunInfo { + if m != nil { + return m.RunInfo + } + return nil +} + +func (m *DownsamplerInput) GetSampleFileList() []*SampleFile { + if m != nil { + return m.SampleFileList + } + return nil +} + +func (m *DownsamplerInput) GetMetricValueCountMax() int64 { + if m != nil && m.MetricValueCountMax != nil { + return *m.MetricValueCountMax + } + return 0 +} + +func (m *DownsamplerInput) GetSampleErrorCountMax() int64 { + if m != nil && m.SampleErrorCountMax != nil { + return *m.SampleErrorCountMax + } + return 0 +} + +func (m *DownsamplerInput) GetBatchSizeMax() int64 { + if m != nil && m.BatchSizeMax != nil { + return *m.BatchSizeMax + } + return 0 +} + +type DownsamplerOutput struct { + SampleBatchList []*SampleBatch `protobuf:"bytes,1,rep,name=sample_batch_list,json=sampleBatchList" json:"sample_batch_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DownsamplerOutput) Reset() { *m = DownsamplerOutput{} } +func (m *DownsamplerOutput) String() string { return proto.CompactTextString(m) } +func (*DownsamplerOutput) ProtoMessage() {} +func (*DownsamplerOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{32} +} + +func (m *DownsamplerOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DownsamplerOutput.Unmarshal(m, b) +} +func (m *DownsamplerOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DownsamplerOutput.Marshal(b, m, deterministic) +} +func (m *DownsamplerOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DownsamplerOutput.Merge(m, src) +} +func (m *DownsamplerOutput) XXX_Size() int { + return xxx_messageInfo_DownsamplerOutput.Size(m) +} +func (m *DownsamplerOutput) XXX_DiscardUnknown() { + xxx_messageInfo_DownsamplerOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_DownsamplerOutput proto.InternalMessageInfo + +func (m *DownsamplerOutput) GetSampleBatchList() []*SampleBatch { + if m != nil { + return m.SampleBatchList + } + return nil +} + +type AnalyzerHistoricQueryInput struct { + BenchmarkInfo *BenchmarkInfo `protobuf:"bytes,1,opt,name=benchmark_info,json=benchmarkInfo" json:"benchmark_info,omitempty"` + RunInfo *RunInfo `protobuf:"bytes,2,opt,name=run_info,json=runInfo" json:"run_info,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerHistoricQueryInput) Reset() { *m = AnalyzerHistoricQueryInput{} } +func (m *AnalyzerHistoricQueryInput) String() string { return proto.CompactTextString(m) } +func (*AnalyzerHistoricQueryInput) ProtoMessage() {} +func (*AnalyzerHistoricQueryInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{33} +} + +func (m *AnalyzerHistoricQueryInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerHistoricQueryInput.Unmarshal(m, b) +} +func (m *AnalyzerHistoricQueryInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerHistoricQueryInput.Marshal(b, m, deterministic) +} +func (m *AnalyzerHistoricQueryInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerHistoricQueryInput.Merge(m, src) +} +func (m *AnalyzerHistoricQueryInput) XXX_Size() int { + return xxx_messageInfo_AnalyzerHistoricQueryInput.Size(m) +} +func (m *AnalyzerHistoricQueryInput) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerHistoricQueryInput.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerHistoricQueryInput proto.InternalMessageInfo + +func (m *AnalyzerHistoricQueryInput) GetBenchmarkInfo() *BenchmarkInfo { + if m != nil { + return m.BenchmarkInfo + } + return nil +} + +func (m *AnalyzerHistoricQueryInput) GetRunInfo() *RunInfo { + if m != nil { + return m.RunInfo + } + return nil +} + +type AnalyzerHistoricQueryOutput struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + RunInfoQueryList []*RunInfoQuery `protobuf:"bytes,2,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"` + GetBatches *bool `protobuf:"varint,3,opt,name=get_batches,json=getBatches,def=1" json:"get_batches,omitempty"` + RunInfoQueryMap map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries `protobuf:"bytes,4,rep,name=run_info_query_map,json=runInfoQueryMap" json:"run_info_query_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerHistoricQueryOutput) Reset() { *m = AnalyzerHistoricQueryOutput{} } +func (m *AnalyzerHistoricQueryOutput) String() string { return proto.CompactTextString(m) } +func (*AnalyzerHistoricQueryOutput) ProtoMessage() {} +func (*AnalyzerHistoricQueryOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{34} +} + +func (m *AnalyzerHistoricQueryOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerHistoricQueryOutput.Unmarshal(m, b) +} +func (m *AnalyzerHistoricQueryOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerHistoricQueryOutput.Marshal(b, m, deterministic) +} +func (m *AnalyzerHistoricQueryOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerHistoricQueryOutput.Merge(m, src) +} +func (m *AnalyzerHistoricQueryOutput) XXX_Size() int { + return xxx_messageInfo_AnalyzerHistoricQueryOutput.Size(m) +} +func (m *AnalyzerHistoricQueryOutput) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerHistoricQueryOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerHistoricQueryOutput proto.InternalMessageInfo + +const Default_AnalyzerHistoricQueryOutput_GetBatches bool = true + +func (m *AnalyzerHistoricQueryOutput) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *AnalyzerHistoricQueryOutput) GetRunInfoQueryList() []*RunInfoQuery { + if m != nil { + return m.RunInfoQueryList + } + return nil +} + +func (m *AnalyzerHistoricQueryOutput) GetGetBatches() bool { + if m != nil && m.GetBatches != nil { + return *m.GetBatches + } + return Default_AnalyzerHistoricQueryOutput_GetBatches +} + +func (m *AnalyzerHistoricQueryOutput) GetRunInfoQueryMap() map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries { + if m != nil { + return m.RunInfoQueryMap + } + return nil +} + +type AnalyzerHistoricQueryOutput_RunInfoQueries struct { + RunInfoQueryList []*RunInfoQuery `protobuf:"bytes,1,rep,name=run_info_query_list,json=runInfoQueryList" json:"run_info_query_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) Reset() { + *m = AnalyzerHistoricQueryOutput_RunInfoQueries{} +} +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) String() string { + return proto.CompactTextString(m) +} +func (*AnalyzerHistoricQueryOutput_RunInfoQueries) ProtoMessage() {} +func (*AnalyzerHistoricQueryOutput_RunInfoQueries) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{34, 0} +} + +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries.Unmarshal(m, b) +} +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries.Marshal(b, m, deterministic) +} +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries.Merge(m, src) +} +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) XXX_Size() int { + return xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries.Size(m) +} +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerHistoricQueryOutput_RunInfoQueries proto.InternalMessageInfo + +func (m *AnalyzerHistoricQueryOutput_RunInfoQueries) GetRunInfoQueryList() []*RunInfoQuery { + if m != nil { + return m.RunInfoQueryList + } + return nil +} + +type AnalyzerInput struct { + RunToBeAnalyzed *RunBundle `protobuf:"bytes,1,opt,name=run_to_be_analyzed,json=runToBeAnalyzed" json:"run_to_be_analyzed,omitempty"` + HistoricalRunList []*RunBundle `protobuf:"bytes,2,rep,name=historical_run_list,json=historicalRunList" json:"historical_run_list,omitempty"` + HistoricalRunMap map[string]*AnalyzerInput_RunBundles `protobuf:"bytes,3,rep,name=historical_run_map,json=historicalRunMap" json:"historical_run_map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerInput) Reset() { *m = AnalyzerInput{} } +func (m *AnalyzerInput) String() string { return proto.CompactTextString(m) } +func (*AnalyzerInput) ProtoMessage() {} +func (*AnalyzerInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{35} +} + +func (m *AnalyzerInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerInput.Unmarshal(m, b) +} +func (m *AnalyzerInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerInput.Marshal(b, m, deterministic) +} +func (m *AnalyzerInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerInput.Merge(m, src) +} +func (m *AnalyzerInput) XXX_Size() int { + return xxx_messageInfo_AnalyzerInput.Size(m) +} +func (m *AnalyzerInput) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerInput.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerInput proto.InternalMessageInfo + +func (m *AnalyzerInput) GetRunToBeAnalyzed() *RunBundle { + if m != nil { + return m.RunToBeAnalyzed + } + return nil +} + +func (m *AnalyzerInput) GetHistoricalRunList() []*RunBundle { + if m != nil { + return m.HistoricalRunList + } + return nil +} + +func (m *AnalyzerInput) GetHistoricalRunMap() map[string]*AnalyzerInput_RunBundles { + if m != nil { + return m.HistoricalRunMap + } + return nil +} + +type AnalyzerInput_RunBundles struct { + HistoricalRunList []*RunBundle `protobuf:"bytes,1,rep,name=historical_run_list,json=historicalRunList" json:"historical_run_list,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerInput_RunBundles) Reset() { *m = AnalyzerInput_RunBundles{} } +func (m *AnalyzerInput_RunBundles) String() string { return proto.CompactTextString(m) } +func (*AnalyzerInput_RunBundles) ProtoMessage() {} +func (*AnalyzerInput_RunBundles) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{35, 0} +} + +func (m *AnalyzerInput_RunBundles) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerInput_RunBundles.Unmarshal(m, b) +} +func (m *AnalyzerInput_RunBundles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerInput_RunBundles.Marshal(b, m, deterministic) +} +func (m *AnalyzerInput_RunBundles) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerInput_RunBundles.Merge(m, src) +} +func (m *AnalyzerInput_RunBundles) XXX_Size() int { + return xxx_messageInfo_AnalyzerInput_RunBundles.Size(m) +} +func (m *AnalyzerInput_RunBundles) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerInput_RunBundles.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerInput_RunBundles proto.InternalMessageInfo + +func (m *AnalyzerInput_RunBundles) GetHistoricalRunList() []*RunBundle { + if m != nil { + return m.HistoricalRunList + } + return nil +} + +type AnalyzerOutput struct { + Status *Status `protobuf:"bytes,1,opt,name=status" json:"status,omitempty"` + Regression *bool `protobuf:"varint,2,opt,name=regression" json:"regression,omitempty"` + RunKey *string `protobuf:"bytes,7,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + AnalysisKey *string `protobuf:"bytes,8,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"` + AnalysisTriageInfo *AnalysisTriageInfo `protobuf:"bytes,10,opt,name=analysis_triage_info,json=analysisTriageInfo" json:"analysis_triage_info,omitempty"` + InputConfig *string `protobuf:"bytes,6,opt,name=input_config,json=inputConfig" json:"input_config,omitempty"` + SerializedInputConfig []byte `protobuf:"bytes,11,opt,name=serialized_input_config,json=serializedInputConfig" json:"serialized_input_config,omitempty"` + Output *string `protobuf:"bytes,3,opt,name=output" json:"output,omitempty"` + SerializedOutput []byte `protobuf:"bytes,12,opt,name=serialized_output,json=serializedOutput" json:"serialized_output,omitempty"` + AnalyzerType *string `protobuf:"bytes,4,opt,name=analyzer_type,json=analyzerType" json:"analyzer_type,omitempty"` + AnalyzerName *string `protobuf:"bytes,5,opt,name=analyzer_name,json=analyzerName" json:"analyzer_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalyzerOutput) Reset() { *m = AnalyzerOutput{} } +func (m *AnalyzerOutput) String() string { return proto.CompactTextString(m) } +func (*AnalyzerOutput) ProtoMessage() {} +func (*AnalyzerOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{36} +} + +func (m *AnalyzerOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalyzerOutput.Unmarshal(m, b) +} +func (m *AnalyzerOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalyzerOutput.Marshal(b, m, deterministic) +} +func (m *AnalyzerOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalyzerOutput.Merge(m, src) +} +func (m *AnalyzerOutput) XXX_Size() int { + return xxx_messageInfo_AnalyzerOutput.Size(m) +} +func (m *AnalyzerOutput) XXX_DiscardUnknown() { + xxx_messageInfo_AnalyzerOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalyzerOutput proto.InternalMessageInfo + +func (m *AnalyzerOutput) GetStatus() *Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *AnalyzerOutput) GetRegression() bool { + if m != nil && m.Regression != nil { + return *m.Regression + } + return false +} + +func (m *AnalyzerOutput) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *AnalyzerOutput) GetAnalysisKey() string { + if m != nil && m.AnalysisKey != nil { + return *m.AnalysisKey + } + return "" +} + +func (m *AnalyzerOutput) GetAnalysisTriageInfo() *AnalysisTriageInfo { + if m != nil { + return m.AnalysisTriageInfo + } + return nil +} + +func (m *AnalyzerOutput) GetInputConfig() string { + if m != nil && m.InputConfig != nil { + return *m.InputConfig + } + return "" +} + +func (m *AnalyzerOutput) GetSerializedInputConfig() []byte { + if m != nil { + return m.SerializedInputConfig + } + return nil +} + +func (m *AnalyzerOutput) GetOutput() string { + if m != nil && m.Output != nil { + return *m.Output + } + return "" +} + +func (m *AnalyzerOutput) GetSerializedOutput() []byte { + if m != nil { + return m.SerializedOutput + } + return nil +} + +func (m *AnalyzerOutput) GetAnalyzerType() string { + if m != nil && m.AnalyzerType != nil { + return *m.AnalyzerType + } + return "" +} + +func (m *AnalyzerOutput) GetAnalyzerName() string { + if m != nil && m.AnalyzerName != nil { + return *m.AnalyzerName + } + return "" +} + +type AnalysisTriageInfo struct { + AnalysisState *AnalysisTriageInfo_AnalysisTriageType `protobuf:"varint,1,opt,name=analysis_state,json=analysisState,enum=mako.AnalysisTriageInfo_AnalysisTriageType" json:"analysis_state,omitempty"` + Environment *AnalysisTriageInfo_EnvironmentType `protobuf:"varint,2,opt,name=environment,enum=mako.AnalysisTriageInfo_EnvironmentType" json:"environment,omitempty"` + Comment *string `protobuf:"bytes,3,opt,name=comment" json:"comment,omitempty"` + BuganizerId *string `protobuf:"bytes,4,opt,name=buganizer_id,json=buganizerId" json:"buganizer_id,omitempty"` + RunKey *string `protobuf:"bytes,5,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + AnalysisKey *string `protobuf:"bytes,6,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AnalysisTriageInfo) Reset() { *m = AnalysisTriageInfo{} } +func (m *AnalysisTriageInfo) String() string { return proto.CompactTextString(m) } +func (*AnalysisTriageInfo) ProtoMessage() {} +func (*AnalysisTriageInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{37} +} + +func (m *AnalysisTriageInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AnalysisTriageInfo.Unmarshal(m, b) +} +func (m *AnalysisTriageInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AnalysisTriageInfo.Marshal(b, m, deterministic) +} +func (m *AnalysisTriageInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_AnalysisTriageInfo.Merge(m, src) +} +func (m *AnalysisTriageInfo) XXX_Size() int { + return xxx_messageInfo_AnalysisTriageInfo.Size(m) +} +func (m *AnalysisTriageInfo) XXX_DiscardUnknown() { + xxx_messageInfo_AnalysisTriageInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_AnalysisTriageInfo proto.InternalMessageInfo + +func (m *AnalysisTriageInfo) GetAnalysisState() AnalysisTriageInfo_AnalysisTriageType { + if m != nil && m.AnalysisState != nil { + return *m.AnalysisState + } + return AnalysisTriageInfo_NONE +} + +func (m *AnalysisTriageInfo) GetEnvironment() AnalysisTriageInfo_EnvironmentType { + if m != nil && m.Environment != nil { + return *m.Environment + } + return AnalysisTriageInfo_UNSPECIFIED +} + +func (m *AnalysisTriageInfo) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +func (m *AnalysisTriageInfo) GetBuganizerId() string { + if m != nil && m.BuganizerId != nil { + return *m.BuganizerId + } + return "" +} + +func (m *AnalysisTriageInfo) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *AnalysisTriageInfo) GetAnalysisKey() string { + if m != nil && m.AnalysisKey != nil { + return *m.AnalysisKey + } + return "" +} + +type DashboardAggregateChartInput struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + ValueSelections []*DataFilter `protobuf:"bytes,2,rep,name=value_selections,json=valueSelections" json:"value_selections,omitempty"` + Tags []string `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"` + RunOrder *RunOrder `protobuf:"varint,8,opt,name=run_order,json=runOrder,enum=mako.RunOrder,def=1" json:"run_order,omitempty"` + MinTimestampMs *float64 `protobuf:"fixed64,4,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"` + MaxTimestampMs *float64 `protobuf:"fixed64,5,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"` + MinBuildId *int64 `protobuf:"varint,9,opt,name=min_build_id,json=minBuildId" json:"min_build_id,omitempty"` + MaxBuildId *int64 `protobuf:"varint,10,opt,name=max_build_id,json=maxBuildId" json:"max_build_id,omitempty"` + MaxRuns *int32 `protobuf:"varint,6,opt,name=max_runs,json=maxRuns" json:"max_runs,omitempty"` + HighlightSeriesOnHover *bool `protobuf:"varint,7,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardAggregateChartInput) Reset() { *m = DashboardAggregateChartInput{} } +func (m *DashboardAggregateChartInput) String() string { return proto.CompactTextString(m) } +func (*DashboardAggregateChartInput) ProtoMessage() {} +func (*DashboardAggregateChartInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{38} +} + +func (m *DashboardAggregateChartInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardAggregateChartInput.Unmarshal(m, b) +} +func (m *DashboardAggregateChartInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardAggregateChartInput.Marshal(b, m, deterministic) +} +func (m *DashboardAggregateChartInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardAggregateChartInput.Merge(m, src) +} +func (m *DashboardAggregateChartInput) XXX_Size() int { + return xxx_messageInfo_DashboardAggregateChartInput.Size(m) +} +func (m *DashboardAggregateChartInput) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardAggregateChartInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardAggregateChartInput proto.InternalMessageInfo + +const Default_DashboardAggregateChartInput_RunOrder RunOrder = RunOrder_TIMESTAMP + +func (m *DashboardAggregateChartInput) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *DashboardAggregateChartInput) GetValueSelections() []*DataFilter { + if m != nil { + return m.ValueSelections + } + return nil +} + +func (m *DashboardAggregateChartInput) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *DashboardAggregateChartInput) GetRunOrder() RunOrder { + if m != nil && m.RunOrder != nil { + return *m.RunOrder + } + return Default_DashboardAggregateChartInput_RunOrder +} + +func (m *DashboardAggregateChartInput) GetMinTimestampMs() float64 { + if m != nil && m.MinTimestampMs != nil { + return *m.MinTimestampMs + } + return 0 +} + +func (m *DashboardAggregateChartInput) GetMaxTimestampMs() float64 { + if m != nil && m.MaxTimestampMs != nil { + return *m.MaxTimestampMs + } + return 0 +} + +func (m *DashboardAggregateChartInput) GetMinBuildId() int64 { + if m != nil && m.MinBuildId != nil { + return *m.MinBuildId + } + return 0 +} + +func (m *DashboardAggregateChartInput) GetMaxBuildId() int64 { + if m != nil && m.MaxBuildId != nil { + return *m.MaxBuildId + } + return 0 +} + +func (m *DashboardAggregateChartInput) GetMaxRuns() int32 { + if m != nil && m.MaxRuns != nil { + return *m.MaxRuns + } + return 0 +} + +func (m *DashboardAggregateChartInput) GetHighlightSeriesOnHover() bool { + if m != nil && m.HighlightSeriesOnHover != nil { + return *m.HighlightSeriesOnHover + } + return false +} + +type DashboardRunChartInput struct { + RunKey *string `protobuf:"bytes,1,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + MetricKeys []string `protobuf:"bytes,2,rep,name=metric_keys,json=metricKeys" json:"metric_keys,omitempty"` + HighlightSeriesOnHover *bool `protobuf:"varint,3,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardRunChartInput) Reset() { *m = DashboardRunChartInput{} } +func (m *DashboardRunChartInput) String() string { return proto.CompactTextString(m) } +func (*DashboardRunChartInput) ProtoMessage() {} +func (*DashboardRunChartInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{39} +} + +func (m *DashboardRunChartInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardRunChartInput.Unmarshal(m, b) +} +func (m *DashboardRunChartInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardRunChartInput.Marshal(b, m, deterministic) +} +func (m *DashboardRunChartInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardRunChartInput.Merge(m, src) +} +func (m *DashboardRunChartInput) XXX_Size() int { + return xxx_messageInfo_DashboardRunChartInput.Size(m) +} +func (m *DashboardRunChartInput) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardRunChartInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardRunChartInput proto.InternalMessageInfo + +func (m *DashboardRunChartInput) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *DashboardRunChartInput) GetMetricKeys() []string { + if m != nil { + return m.MetricKeys + } + return nil +} + +func (m *DashboardRunChartInput) GetHighlightSeriesOnHover() bool { + if m != nil && m.HighlightSeriesOnHover != nil { + return *m.HighlightSeriesOnHover + } + return false +} + +type DashboardCompareAggregateChartInput struct { + SeriesList []*DashboardCompareAggregateChartInput_Series `protobuf:"bytes,1,rep,name=series_list,json=seriesList" json:"series_list,omitempty"` + MinTimestampMs *float64 `protobuf:"fixed64,2,opt,name=min_timestamp_ms,json=minTimestampMs" json:"min_timestamp_ms,omitempty"` + MaxTimestampMs *float64 `protobuf:"fixed64,3,opt,name=max_timestamp_ms,json=maxTimestampMs" json:"max_timestamp_ms,omitempty"` + MaxRuns *int32 `protobuf:"varint,4,opt,name=max_runs,json=maxRuns" json:"max_runs,omitempty"` + HighlightSeriesOnHover *bool `protobuf:"varint,5,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardCompareAggregateChartInput) Reset() { *m = DashboardCompareAggregateChartInput{} } +func (m *DashboardCompareAggregateChartInput) String() string { return proto.CompactTextString(m) } +func (*DashboardCompareAggregateChartInput) ProtoMessage() {} +func (*DashboardCompareAggregateChartInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{40} +} + +func (m *DashboardCompareAggregateChartInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardCompareAggregateChartInput.Unmarshal(m, b) +} +func (m *DashboardCompareAggregateChartInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardCompareAggregateChartInput.Marshal(b, m, deterministic) +} +func (m *DashboardCompareAggregateChartInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardCompareAggregateChartInput.Merge(m, src) +} +func (m *DashboardCompareAggregateChartInput) XXX_Size() int { + return xxx_messageInfo_DashboardCompareAggregateChartInput.Size(m) +} +func (m *DashboardCompareAggregateChartInput) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardCompareAggregateChartInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardCompareAggregateChartInput proto.InternalMessageInfo + +func (m *DashboardCompareAggregateChartInput) GetSeriesList() []*DashboardCompareAggregateChartInput_Series { + if m != nil { + return m.SeriesList + } + return nil +} + +func (m *DashboardCompareAggregateChartInput) GetMinTimestampMs() float64 { + if m != nil && m.MinTimestampMs != nil { + return *m.MinTimestampMs + } + return 0 +} + +func (m *DashboardCompareAggregateChartInput) GetMaxTimestampMs() float64 { + if m != nil && m.MaxTimestampMs != nil { + return *m.MaxTimestampMs + } + return 0 +} + +func (m *DashboardCompareAggregateChartInput) GetMaxRuns() int32 { + if m != nil && m.MaxRuns != nil { + return *m.MaxRuns + } + return 0 +} + +func (m *DashboardCompareAggregateChartInput) GetHighlightSeriesOnHover() bool { + if m != nil && m.HighlightSeriesOnHover != nil { + return *m.HighlightSeriesOnHover + } + return false +} + +type DashboardCompareAggregateChartInput_Series struct { + SeriesLabel *string `protobuf:"bytes,1,opt,name=series_label,json=seriesLabel" json:"series_label,omitempty"` + BenchmarkKey *string `protobuf:"bytes,2,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + ValueSelection *DataFilter `protobuf:"bytes,3,opt,name=value_selection,json=valueSelection" json:"value_selection,omitempty"` + Tags []string `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardCompareAggregateChartInput_Series) Reset() { + *m = DashboardCompareAggregateChartInput_Series{} +} +func (m *DashboardCompareAggregateChartInput_Series) String() string { + return proto.CompactTextString(m) +} +func (*DashboardCompareAggregateChartInput_Series) ProtoMessage() {} +func (*DashboardCompareAggregateChartInput_Series) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{40, 0} +} + +func (m *DashboardCompareAggregateChartInput_Series) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardCompareAggregateChartInput_Series.Unmarshal(m, b) +} +func (m *DashboardCompareAggregateChartInput_Series) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardCompareAggregateChartInput_Series.Marshal(b, m, deterministic) +} +func (m *DashboardCompareAggregateChartInput_Series) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardCompareAggregateChartInput_Series.Merge(m, src) +} +func (m *DashboardCompareAggregateChartInput_Series) XXX_Size() int { + return xxx_messageInfo_DashboardCompareAggregateChartInput_Series.Size(m) +} +func (m *DashboardCompareAggregateChartInput_Series) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardCompareAggregateChartInput_Series.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardCompareAggregateChartInput_Series proto.InternalMessageInfo + +func (m *DashboardCompareAggregateChartInput_Series) GetSeriesLabel() string { + if m != nil && m.SeriesLabel != nil { + return *m.SeriesLabel + } + return "" +} + +func (m *DashboardCompareAggregateChartInput_Series) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *DashboardCompareAggregateChartInput_Series) GetValueSelection() *DataFilter { + if m != nil { + return m.ValueSelection + } + return nil +} + +func (m *DashboardCompareAggregateChartInput_Series) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +type DashboardCompareRunChartInput struct { + RunKeys []string `protobuf:"bytes,1,rep,name=run_keys,json=runKeys" json:"run_keys,omitempty"` + MetricKeys []string `protobuf:"bytes,2,rep,name=metric_keys,json=metricKeys" json:"metric_keys,omitempty"` + HighlightSeriesOnHover *bool `protobuf:"varint,3,opt,name=highlight_series_on_hover,json=highlightSeriesOnHover" json:"highlight_series_on_hover,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardCompareRunChartInput) Reset() { *m = DashboardCompareRunChartInput{} } +func (m *DashboardCompareRunChartInput) String() string { return proto.CompactTextString(m) } +func (*DashboardCompareRunChartInput) ProtoMessage() {} +func (*DashboardCompareRunChartInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{41} +} + +func (m *DashboardCompareRunChartInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardCompareRunChartInput.Unmarshal(m, b) +} +func (m *DashboardCompareRunChartInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardCompareRunChartInput.Marshal(b, m, deterministic) +} +func (m *DashboardCompareRunChartInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardCompareRunChartInput.Merge(m, src) +} +func (m *DashboardCompareRunChartInput) XXX_Size() int { + return xxx_messageInfo_DashboardCompareRunChartInput.Size(m) +} +func (m *DashboardCompareRunChartInput) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardCompareRunChartInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardCompareRunChartInput proto.InternalMessageInfo + +func (m *DashboardCompareRunChartInput) GetRunKeys() []string { + if m != nil { + return m.RunKeys + } + return nil +} + +func (m *DashboardCompareRunChartInput) GetMetricKeys() []string { + if m != nil { + return m.MetricKeys + } + return nil +} + +func (m *DashboardCompareRunChartInput) GetHighlightSeriesOnHover() bool { + if m != nil && m.HighlightSeriesOnHover != nil { + return *m.HighlightSeriesOnHover + } + return false +} + +type DashboardVisualizeAnalysisInput struct { + RunKey *string `protobuf:"bytes,1,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + AnalysisKey *string `protobuf:"bytes,2,opt,name=analysis_key,json=analysisKey" json:"analysis_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DashboardVisualizeAnalysisInput) Reset() { *m = DashboardVisualizeAnalysisInput{} } +func (m *DashboardVisualizeAnalysisInput) String() string { return proto.CompactTextString(m) } +func (*DashboardVisualizeAnalysisInput) ProtoMessage() {} +func (*DashboardVisualizeAnalysisInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{42} +} + +func (m *DashboardVisualizeAnalysisInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DashboardVisualizeAnalysisInput.Unmarshal(m, b) +} +func (m *DashboardVisualizeAnalysisInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DashboardVisualizeAnalysisInput.Marshal(b, m, deterministic) +} +func (m *DashboardVisualizeAnalysisInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_DashboardVisualizeAnalysisInput.Merge(m, src) +} +func (m *DashboardVisualizeAnalysisInput) XXX_Size() int { + return xxx_messageInfo_DashboardVisualizeAnalysisInput.Size(m) +} +func (m *DashboardVisualizeAnalysisInput) XXX_DiscardUnknown() { + xxx_messageInfo_DashboardVisualizeAnalysisInput.DiscardUnknown(m) +} + +var xxx_messageInfo_DashboardVisualizeAnalysisInput proto.InternalMessageInfo + +func (m *DashboardVisualizeAnalysisInput) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *DashboardVisualizeAnalysisInput) GetAnalysisKey() string { + if m != nil && m.AnalysisKey != nil { + return *m.AnalysisKey + } + return "" +} + +type TestOption struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TestOption) Reset() { *m = TestOption{} } +func (m *TestOption) String() string { return proto.CompactTextString(m) } +func (*TestOption) ProtoMessage() {} +func (*TestOption) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{43} +} + +func (m *TestOption) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TestOption.Unmarshal(m, b) +} +func (m *TestOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TestOption.Marshal(b, m, deterministic) +} +func (m *TestOption) XXX_Merge(src proto.Message) { + xxx_messageInfo_TestOption.Merge(m, src) +} +func (m *TestOption) XXX_Size() int { + return xxx_messageInfo_TestOption.Size(m) +} +func (m *TestOption) XXX_DiscardUnknown() { + xxx_messageInfo_TestOption.DiscardUnknown(m) +} + +var xxx_messageInfo_TestOption proto.InternalMessageInfo + +func (m *TestOption) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *TestOption) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type TestInput struct { + BenchmarkKey *string `protobuf:"bytes,1,opt,name=benchmark_key,json=benchmarkKey" json:"benchmark_key,omitempty"` + TempDir *string `protobuf:"bytes,2,opt,name=temp_dir,json=tempDir" json:"temp_dir,omitempty"` + TimeoutSec *float64 `protobuf:"fixed64,3,opt,name=timeout_sec,json=timeoutSec" json:"timeout_sec,omitempty"` + TestOptionList []*TestOption `protobuf:"bytes,4,rep,name=test_option_list,json=testOptionList" json:"test_option_list,omitempty"` + Tags []string `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"` + TestPassId *string `protobuf:"bytes,7,opt,name=test_pass_id,json=testPassId" json:"test_pass_id,omitempty"` + BuildId *int64 `protobuf:"varint,8,opt,name=build_id,json=buildId" json:"build_id,omitempty"` + InternalTestOptions map[string]string `protobuf:"bytes,10,rep,name=internal_test_options,json=internalTestOptions" json:"internal_test_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TestInput) Reset() { *m = TestInput{} } +func (m *TestInput) String() string { return proto.CompactTextString(m) } +func (*TestInput) ProtoMessage() {} +func (*TestInput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{44} +} + +func (m *TestInput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TestInput.Unmarshal(m, b) +} +func (m *TestInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TestInput.Marshal(b, m, deterministic) +} +func (m *TestInput) XXX_Merge(src proto.Message) { + xxx_messageInfo_TestInput.Merge(m, src) +} +func (m *TestInput) XXX_Size() int { + return xxx_messageInfo_TestInput.Size(m) +} +func (m *TestInput) XXX_DiscardUnknown() { + xxx_messageInfo_TestInput.DiscardUnknown(m) +} + +var xxx_messageInfo_TestInput proto.InternalMessageInfo + +func (m *TestInput) GetBenchmarkKey() string { + if m != nil && m.BenchmarkKey != nil { + return *m.BenchmarkKey + } + return "" +} + +func (m *TestInput) GetTempDir() string { + if m != nil && m.TempDir != nil { + return *m.TempDir + } + return "" +} + +func (m *TestInput) GetTimeoutSec() float64 { + if m != nil && m.TimeoutSec != nil { + return *m.TimeoutSec + } + return 0 +} + +func (m *TestInput) GetTestOptionList() []*TestOption { + if m != nil { + return m.TestOptionList + } + return nil +} + +func (m *TestInput) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *TestInput) GetTestPassId() string { + if m != nil && m.TestPassId != nil { + return *m.TestPassId + } + return "" +} + +func (m *TestInput) GetBuildId() int64 { + if m != nil && m.BuildId != nil { + return *m.BuildId + } + return 0 +} + +func (m *TestInput) GetInternalTestOptions() map[string]string { + if m != nil { + return m.InternalTestOptions + } + return nil +} + +type TestOutput struct { + TestStatus *TestOutput_TestStatus `protobuf:"varint,1,opt,name=test_status,json=testStatus,enum=mako.TestOutput_TestStatus" json:"test_status,omitempty"` + AnalyzerOutputList []*AnalyzerOutput `protobuf:"bytes,2,rep,name=analyzer_output_list,json=analyzerOutputList" json:"analyzer_output_list,omitempty"` + SummaryOutput *string `protobuf:"bytes,3,opt,name=summary_output,json=summaryOutput" json:"summary_output,omitempty"` + RunChartLink *string `protobuf:"bytes,4,opt,name=run_chart_link,json=runChartLink" json:"run_chart_link,omitempty"` + RunKey *string `protobuf:"bytes,5,opt,name=run_key,json=runKey" json:"run_key,omitempty"` + RetryableFailureType *TestOutput_RetryableFailureType `protobuf:"varint,6,opt,name=retryable_failure_type,json=retryableFailureType,enum=mako.TestOutput_RetryableFailureType" json:"retryable_failure_type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TestOutput) Reset() { *m = TestOutput{} } +func (m *TestOutput) String() string { return proto.CompactTextString(m) } +func (*TestOutput) ProtoMessage() {} +func (*TestOutput) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{45} +} + +func (m *TestOutput) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TestOutput.Unmarshal(m, b) +} +func (m *TestOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TestOutput.Marshal(b, m, deterministic) +} +func (m *TestOutput) XXX_Merge(src proto.Message) { + xxx_messageInfo_TestOutput.Merge(m, src) +} +func (m *TestOutput) XXX_Size() int { + return xxx_messageInfo_TestOutput.Size(m) +} +func (m *TestOutput) XXX_DiscardUnknown() { + xxx_messageInfo_TestOutput.DiscardUnknown(m) +} + +var xxx_messageInfo_TestOutput proto.InternalMessageInfo + +func (m *TestOutput) GetTestStatus() TestOutput_TestStatus { + if m != nil && m.TestStatus != nil { + return *m.TestStatus + } + return TestOutput_PASS +} + +func (m *TestOutput) GetAnalyzerOutputList() []*AnalyzerOutput { + if m != nil { + return m.AnalyzerOutputList + } + return nil +} + +func (m *TestOutput) GetSummaryOutput() string { + if m != nil && m.SummaryOutput != nil { + return *m.SummaryOutput + } + return "" +} + +func (m *TestOutput) GetRunChartLink() string { + if m != nil && m.RunChartLink != nil { + return *m.RunChartLink + } + return "" +} + +func (m *TestOutput) GetRunKey() string { + if m != nil && m.RunKey != nil { + return *m.RunKey + } + return "" +} + +func (m *TestOutput) GetRetryableFailureType() TestOutput_RetryableFailureType { + if m != nil && m.RetryableFailureType != nil { + return *m.RetryableFailureType + } + return TestOutput_UNKNOWN_OR_UNSET_TYPE +} + +type SampleRecord struct { + SamplePoint *SamplePoint `protobuf:"bytes,1,opt,name=sample_point,json=samplePoint" json:"sample_point,omitempty"` + SampleError *SampleError `protobuf:"bytes,2,opt,name=sample_error,json=sampleError" json:"sample_error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleRecord) Reset() { *m = SampleRecord{} } +func (m *SampleRecord) String() string { return proto.CompactTextString(m) } +func (*SampleRecord) ProtoMessage() {} +func (*SampleRecord) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{46} +} + +func (m *SampleRecord) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleRecord.Unmarshal(m, b) +} +func (m *SampleRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleRecord.Marshal(b, m, deterministic) +} +func (m *SampleRecord) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleRecord.Merge(m, src) +} +func (m *SampleRecord) XXX_Size() int { + return xxx_messageInfo_SampleRecord.Size(m) +} +func (m *SampleRecord) XXX_DiscardUnknown() { + xxx_messageInfo_SampleRecord.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleRecord proto.InternalMessageInfo + +func (m *SampleRecord) GetSamplePoint() *SamplePoint { + if m != nil { + return m.SamplePoint + } + return nil +} + +func (m *SampleRecord) GetSampleError() *SampleError { + if m != nil { + return m.SampleError + } + return nil +} + +type SampleFile struct { + SamplerName *string `protobuf:"bytes,1,opt,name=sampler_name,json=samplerName" json:"sampler_name,omitempty"` + FilePath *string `protobuf:"bytes,2,opt,name=file_path,json=filePath" json:"file_path,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SampleFile) Reset() { *m = SampleFile{} } +func (m *SampleFile) String() string { return proto.CompactTextString(m) } +func (*SampleFile) ProtoMessage() {} +func (*SampleFile) Descriptor() ([]byte, []int) { + return fileDescriptor_b174f87a83ddb952, []int{47} +} + +func (m *SampleFile) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SampleFile.Unmarshal(m, b) +} +func (m *SampleFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SampleFile.Marshal(b, m, deterministic) +} +func (m *SampleFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_SampleFile.Merge(m, src) +} +func (m *SampleFile) XXX_Size() int { + return xxx_messageInfo_SampleFile.Size(m) +} +func (m *SampleFile) XXX_DiscardUnknown() { + xxx_messageInfo_SampleFile.DiscardUnknown(m) +} + +var xxx_messageInfo_SampleFile proto.InternalMessageInfo + +func (m *SampleFile) GetSamplerName() string { + if m != nil && m.SamplerName != nil { + return *m.SamplerName + } + return "" +} + +func (m *SampleFile) GetFilePath() string { + if m != nil && m.FilePath != nil { + return *m.FilePath + } + return "" +} + +func init() { + proto.RegisterEnum("mako.RunOrder", RunOrder_name, RunOrder_value) + proto.RegisterEnum("mako.Status_Code", Status_Code_name, Status_Code_value) + proto.RegisterEnum("mako.ValueInfo_Type", ValueInfo_Type_name, ValueInfo_Type_value) + proto.RegisterEnum("mako.DataFilter_DataType", DataFilter_DataType_name, DataFilter_DataType_value) + proto.RegisterEnum("mako.AnalysisTriageInfo_AnalysisTriageType", AnalysisTriageInfo_AnalysisTriageType_name, AnalysisTriageInfo_AnalysisTriageType_value) + proto.RegisterEnum("mako.AnalysisTriageInfo_EnvironmentType", AnalysisTriageInfo_EnvironmentType_name, AnalysisTriageInfo_EnvironmentType_value) + proto.RegisterEnum("mako.TestOutput_TestStatus", TestOutput_TestStatus_name, TestOutput_TestStatus_value) + proto.RegisterEnum("mako.TestOutput_RetryableFailureType", TestOutput_RetryableFailureType_name, TestOutput_RetryableFailureType_value) + proto.RegisterType((*Status)(nil), "mako.Status") + proto.RegisterType((*ValueInfo)(nil), "mako.ValueInfo") + proto.RegisterType((*KeyedValue)(nil), "mako.KeyedValue") + proto.RegisterType((*NamedData)(nil), "mako.NamedData") + proto.RegisterType((*Range)(nil), "mako.Range") + proto.RegisterType((*LabeledRange)(nil), "mako.LabeledRange") + proto.RegisterType((*DataFilter)(nil), "mako.DataFilter") + proto.RegisterType((*RunBundle)(nil), "mako.RunBundle") + proto.RegisterType((*BenchmarkInfo)(nil), "mako.BenchmarkInfo") + proto.RegisterType((*RunAnnotation)(nil), "mako.RunAnnotation") + proto.RegisterType((*RunInfo)(nil), "mako.RunInfo") + proto.RegisterType((*SamplePoint)(nil), "mako.SamplePoint") + proto.RegisterMapType((map[string][]byte)(nil), "mako.SamplePoint.AuxDataEntry") + proto.RegisterType((*SampleAnnotation)(nil), "mako.SampleAnnotation") + proto.RegisterType((*SampleError)(nil), "mako.SampleError") + proto.RegisterType((*SampleBatch)(nil), "mako.SampleBatch") + proto.RegisterType((*MetricAggregate)(nil), "mako.MetricAggregate") + proto.RegisterType((*RunAggregate)(nil), "mako.RunAggregate") + proto.RegisterType((*Aggregate)(nil), "mako.Aggregate") + proto.RegisterType((*BenchmarkInfoQuery)(nil), "mako.BenchmarkInfoQuery") + proto.RegisterType((*BenchmarkInfoQueryResponse)(nil), "mako.BenchmarkInfoQueryResponse") + proto.RegisterType((*RunInfoQuery)(nil), "mako.RunInfoQuery") + proto.RegisterType((*RunInfoQueryResponse)(nil), "mako.RunInfoQueryResponse") + proto.RegisterType((*SampleBatchQuery)(nil), "mako.SampleBatchQuery") + proto.RegisterType((*SampleBatchQueryResponse)(nil), "mako.SampleBatchQueryResponse") + proto.RegisterType((*CreationResponse)(nil), "mako.CreationResponse") + proto.RegisterType((*ModificationResponse)(nil), "mako.ModificationResponse") + proto.RegisterType((*CountResponse)(nil), "mako.CountResponse") + proto.RegisterType((*SecondaryStorageWriteInput)(nil), "mako.SecondaryStorageWriteInput") + proto.RegisterType((*SecondaryStorageWriteOutput)(nil), "mako.SecondaryStorageWriteOutput") + proto.RegisterType((*AggregatorInput)(nil), "mako.AggregatorInput") + proto.RegisterType((*AggregatorOutput)(nil), "mako.AggregatorOutput") + proto.RegisterType((*DownsamplerInput)(nil), "mako.DownsamplerInput") + proto.RegisterType((*DownsamplerOutput)(nil), "mako.DownsamplerOutput") + proto.RegisterType((*AnalyzerHistoricQueryInput)(nil), "mako.AnalyzerHistoricQueryInput") + proto.RegisterType((*AnalyzerHistoricQueryOutput)(nil), "mako.AnalyzerHistoricQueryOutput") + proto.RegisterMapType((map[string]*AnalyzerHistoricQueryOutput_RunInfoQueries)(nil), "mako.AnalyzerHistoricQueryOutput.RunInfoQueryMapEntry") + proto.RegisterType((*AnalyzerHistoricQueryOutput_RunInfoQueries)(nil), "mako.AnalyzerHistoricQueryOutput.RunInfoQueries") + proto.RegisterType((*AnalyzerInput)(nil), "mako.AnalyzerInput") + proto.RegisterMapType((map[string]*AnalyzerInput_RunBundles)(nil), "mako.AnalyzerInput.HistoricalRunMapEntry") + proto.RegisterType((*AnalyzerInput_RunBundles)(nil), "mako.AnalyzerInput.RunBundles") + proto.RegisterType((*AnalyzerOutput)(nil), "mako.AnalyzerOutput") + proto.RegisterType((*AnalysisTriageInfo)(nil), "mako.AnalysisTriageInfo") + proto.RegisterType((*DashboardAggregateChartInput)(nil), "mako.DashboardAggregateChartInput") + proto.RegisterType((*DashboardRunChartInput)(nil), "mako.DashboardRunChartInput") + proto.RegisterType((*DashboardCompareAggregateChartInput)(nil), "mako.DashboardCompareAggregateChartInput") + proto.RegisterType((*DashboardCompareAggregateChartInput_Series)(nil), "mako.DashboardCompareAggregateChartInput.Series") + proto.RegisterType((*DashboardCompareRunChartInput)(nil), "mako.DashboardCompareRunChartInput") + proto.RegisterType((*DashboardVisualizeAnalysisInput)(nil), "mako.DashboardVisualizeAnalysisInput") + proto.RegisterType((*TestOption)(nil), "mako.TestOption") + proto.RegisterType((*TestInput)(nil), "mako.TestInput") + proto.RegisterMapType((map[string]string)(nil), "mako.TestInput.InternalTestOptionsEntry") + proto.RegisterType((*TestOutput)(nil), "mako.TestOutput") + proto.RegisterType((*SampleRecord)(nil), "mako.SampleRecord") + proto.RegisterType((*SampleFile)(nil), "mako.SampleFile") +} + +func init() { proto.RegisterFile("spec/proto/mako.proto", fileDescriptor_b174f87a83ddb952) } + +var fileDescriptor_b174f87a83ddb952 = []byte{ + // 3822 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3a, 0x5d, 0x6f, 0x23, 0x47, + 0x72, 0x3b, 0xfc, 0x12, 0x59, 0xa4, 0xc8, 0x51, 0x4b, 0xda, 0xa5, 0xa4, 0xb3, 0x2d, 0x8f, 0xb3, + 0x38, 0x9d, 0x8d, 0xdb, 0x5d, 0xeb, 0x8c, 0xcd, 0x59, 0x76, 0x72, 0xa0, 0x28, 0x6a, 0x97, 0xbb, + 0x22, 0x29, 0x37, 0x29, 0x3b, 0xc6, 0x25, 0x18, 0xb4, 0xc8, 0x16, 0x35, 0xb7, 0xe4, 0x0c, 0x33, + 0x33, 0x5c, 0x4b, 0xfb, 0x18, 0x04, 0x48, 0x02, 0xe4, 0xde, 0x82, 0x24, 0xc0, 0x3d, 0xdc, 0x43, + 0x90, 0x97, 0xbc, 0x1e, 0xf2, 0x90, 0xbc, 0xe4, 0x25, 0x40, 0x5e, 0xf2, 0x17, 0xf2, 0x16, 0xe4, + 0x77, 0x04, 0x5d, 0xdd, 0x33, 0xd3, 0xfc, 0xd0, 0xae, 0xd6, 0x67, 0xfb, 0x6d, 0xba, 0xba, 0xaa, + 0xba, 0xba, 0xaa, 0xba, 0xba, 0xaa, 0x7a, 0x60, 0x33, 0x98, 0xf0, 0xfe, 0xc3, 0x89, 0xef, 0x85, + 0xde, 0xc3, 0x31, 0x7b, 0xe1, 0x3d, 0xc0, 0x4f, 0x92, 0x11, 0xdf, 0xd6, 0xbf, 0x19, 0x90, 0xeb, + 0x86, 0x2c, 0x9c, 0x06, 0xe4, 0x3e, 0x64, 0xfa, 0xde, 0x80, 0x57, 0x8d, 0x5d, 0x63, 0xaf, 0xbc, + 0xbf, 0xf6, 0x00, 0x71, 0xe5, 0xdc, 0x83, 0xba, 0x37, 0xe0, 0x14, 0xa7, 0xc9, 0xfb, 0x50, 0xba, + 0x60, 0xce, 0xc8, 0x1e, 0xf3, 0x20, 0x60, 0x43, 0x5e, 0x4d, 0xed, 0x1a, 0x7b, 0x05, 0x5a, 0x14, + 0xb0, 0x96, 0x04, 0x91, 0x1d, 0xc8, 0xfa, 0x3c, 0xf4, 0xaf, 0xab, 0xe9, 0x5d, 0x63, 0x2f, 0x7f, + 0x90, 0xbd, 0x60, 0xa3, 0x80, 0x53, 0x09, 0x23, 0x3f, 0x01, 0xf3, 0x1b, 0xe6, 0xbb, 0x8e, 0x3b, + 0x8c, 0x58, 0x04, 0xd5, 0xcc, 0x6e, 0x7a, 0xaf, 0x40, 0x2b, 0x0a, 0xae, 0xd8, 0x04, 0xd6, 0x3b, + 0x90, 0x11, 0x0b, 0x93, 0x22, 0xac, 0x74, 0xcf, 0xea, 0xf5, 0x46, 0xb7, 0x6b, 0xde, 0x21, 0x79, + 0xc8, 0x1c, 0xd7, 0x9a, 0x27, 0xa6, 0x61, 0xfd, 0xad, 0x01, 0x85, 0x2f, 0xd9, 0x68, 0xca, 0x9b, + 0xee, 0x85, 0x47, 0x76, 0xa0, 0xf0, 0x52, 0x0c, 0xec, 0x17, 0xfc, 0x1a, 0xf7, 0x50, 0xa0, 0x79, + 0x04, 0x3c, 0xe7, 0xd7, 0x64, 0x03, 0xb2, 0x23, 0x76, 0xce, 0x47, 0x4a, 0x5a, 0x39, 0x20, 0x7b, + 0x90, 0x09, 0xaf, 0x27, 0x1c, 0xc5, 0x2c, 0xef, 0x6f, 0xc8, 0x1d, 0xc7, 0x1c, 0x1f, 0xf4, 0xae, + 0x27, 0x9c, 0x22, 0x86, 0x65, 0x41, 0x46, 0x8c, 0x84, 0x24, 0xed, 0xb3, 0x56, 0x83, 0x36, 0xeb, + 0xa6, 0x41, 0x56, 0xa1, 0xd0, 0x6b, 0xb6, 0x1a, 0xdd, 0x5e, 0xad, 0x75, 0x6a, 0xa6, 0xac, 0x5f, + 0x00, 0x3c, 0xe7, 0xd7, 0x7c, 0x80, 0x0c, 0xde, 0x28, 0x0e, 0x7e, 0xa3, 0x38, 0x06, 0x95, 0x03, + 0xeb, 0x67, 0x50, 0x68, 0xb3, 0x31, 0x1f, 0x1c, 0xb1, 0x90, 0x11, 0x02, 0x19, 0x97, 0x8d, 0xb9, + 0x22, 0xc5, 0x6f, 0x01, 0x1b, 0xb0, 0x90, 0xa9, 0x4d, 0xe0, 0xb7, 0xf5, 0x10, 0xb2, 0x94, 0xb9, + 0x43, 0x2e, 0x78, 0x06, 0x21, 0xf3, 0x43, 0xa4, 0x30, 0xa8, 0x1c, 0x10, 0x13, 0xd2, 0xdc, 0x1d, + 0xa8, 0x75, 0xc4, 0xa7, 0xf5, 0x04, 0x4a, 0x27, 0x62, 0xf7, 0x7c, 0x10, 0xd3, 0x49, 0xd5, 0x18, + 0xba, 0x6a, 0xde, 0x87, 0xac, 0x2f, 0xa6, 0x91, 0xb2, 0xb8, 0x5f, 0x94, 0xba, 0x41, 0x0a, 0x2a, + 0x67, 0xac, 0x5f, 0x67, 0x00, 0x84, 0xa8, 0xc7, 0xce, 0x28, 0xe4, 0x3e, 0x79, 0x0c, 0x05, 0x21, + 0x90, 0x8d, 0x1a, 0x95, 0x3e, 0xb4, 0x25, 0xa9, 0x12, 0x24, 0xfc, 0x44, 0xb5, 0xe6, 0x07, 0xea, + 0x6b, 0x56, 0x51, 0xa9, 0x39, 0x45, 0xed, 0xc3, 0xe6, 0x84, 0xfb, 0x7d, 0xee, 0x86, 0xce, 0x88, + 0xdb, 0x63, 0x67, 0x34, 0x72, 0x6c, 0x9f, 0xb9, 0x2f, 0xd0, 0x64, 0x59, 0xba, 0x9e, 0x4c, 0xb6, + 0xc4, 0x1c, 0x65, 0xee, 0x0b, 0xf2, 0x09, 0xac, 0x3b, 0x43, 0xd7, 0xf3, 0x05, 0x7e, 0x10, 0x08, + 0x3f, 0x43, 0xa5, 0x65, 0xd0, 0x17, 0x33, 0xa1, 0x3f, 0xe5, 0x74, 0x4d, 0x22, 0xb4, 0xe4, 0xbc, + 0x10, 0xca, 0xfa, 0x8f, 0x14, 0xe4, 0x23, 0xe9, 0xc8, 0x36, 0xdc, 0x6d, 0x35, 0x7a, 0xb4, 0x59, + 0xb7, 0x6b, 0x4f, 0x9e, 0xd0, 0xc6, 0x93, 0x5a, 0xaf, 0x61, 0xd7, 0x3b, 0x67, 0xed, 0x9e, 0x59, + 0x24, 0x55, 0xd8, 0x58, 0x98, 0x6b, 0x35, 0xdb, 0xa6, 0xb1, 0x7c, 0xa6, 0xf6, 0x27, 0x66, 0x8a, + 0x6c, 0xc1, 0xe6, 0xe2, 0x4c, 0xa3, 0xd6, 0x36, 0xd3, 0x64, 0x07, 0xee, 0x2d, 0x99, 0x3a, 0x6a, + 0xd6, 0xda, 0x66, 0x66, 0xe9, 0x64, 0xb7, 0x77, 0x74, 0xd4, 0xf8, 0xd2, 0xcc, 0xde, 0xb0, 0xdc, + 0x91, 0x59, 0x22, 0xef, 0xc1, 0xce, 0xc2, 0xcc, 0x69, 0x83, 0xd6, 0x1b, 0xed, 0x5e, 0xf3, 0xa4, + 0x61, 0xe6, 0xc8, 0x06, 0x98, 0xf5, 0xb3, 0x6e, 0xaf, 0xd3, 0x4a, 0x10, 0xcc, 0x15, 0x72, 0x0f, + 0xd6, 0x15, 0x59, 0xb7, 0xd6, 0x3a, 0x3d, 0x69, 0x9c, 0x76, 0x9a, 0xed, 0x5e, 0xd7, 0xcc, 0x93, + 0x75, 0xa8, 0x1c, 0x36, 0xda, 0xf5, 0xa7, 0xad, 0x1a, 0x7d, 0x6e, 0x77, 0xeb, 0x1d, 0xda, 0x30, + 0x0b, 0xa4, 0x02, 0xc5, 0x06, 0xa5, 0x1d, 0xaa, 0x14, 0x03, 0xd6, 0x3f, 0x19, 0x50, 0xa0, 0x53, + 0xf7, 0x70, 0xea, 0x0e, 0x46, 0x9c, 0x1c, 0x40, 0xf9, 0x9c, 0xbb, 0xfd, 0xcb, 0x31, 0xf3, 0x5f, + 0xd8, 0x8e, 0x7b, 0xe1, 0xa1, 0x4f, 0x14, 0xf7, 0xd7, 0xa5, 0x4f, 0x1c, 0x46, 0x73, 0xe2, 0xa4, + 0xd1, 0xd5, 0x73, 0x7d, 0x48, 0xf6, 0x20, 0xef, 0x4f, 0x5d, 0x49, 0x25, 0xfd, 0x6f, 0x55, 0xf9, + 0xdf, 0xd4, 0x45, 0xfc, 0x15, 0x5f, 0x7e, 0x90, 0x47, 0x00, 0xe7, 0x2c, 0xec, 0x5f, 0xda, 0x23, + 0x27, 0x08, 0xab, 0xe9, 0xdd, 0xf4, 0x5e, 0x31, 0x8e, 0x5c, 0x6c, 0x3c, 0x19, 0xf1, 0x43, 0x31, + 0x4b, 0x0b, 0x88, 0x74, 0xe2, 0x04, 0xa1, 0xf5, 0x37, 0x59, 0x58, 0x9d, 0x59, 0x9c, 0x7c, 0x00, + 0xc9, 0xf2, 0xda, 0x69, 0x2d, 0xc5, 0x40, 0xe1, 0x88, 0xf7, 0xf5, 0xed, 0xe0, 0xc1, 0x94, 0xae, + 0x9a, 0x90, 0x8a, 0xa3, 0x2b, 0x82, 0xe3, 0xc4, 0xf7, 0x7e, 0xc5, 0xfb, 0xa1, 0x44, 0x4a, 0xcb, + 0xe0, 0xa8, 0x60, 0x88, 0xf2, 0x0e, 0x80, 0xf7, 0x8d, 0xcb, 0x7d, 0x29, 0xb2, 0x8c, 0x7c, 0x05, + 0x84, 0x08, 0xf9, 0xc8, 0xa7, 0x60, 0x3a, 0xee, 0x64, 0x1a, 0xda, 0xf2, 0x50, 0xa0, 0x0e, 0xb2, + 0xa8, 0x83, 0xca, 0x5c, 0x7c, 0xa2, 0x65, 0x44, 0x4c, 0x22, 0xe0, 0xa7, 0x60, 0x8e, 0x79, 0xe8, + 0x3b, 0x7d, 0xa4, 0x92, 0xfc, 0x73, 0xa8, 0x92, 0x45, 0x52, 0x89, 0x28, 0xbe, 0x71, 0xd5, 0x53, + 0xf8, 0x51, 0x7f, 0x1a, 0x84, 0xde, 0xd8, 0x66, 0xc3, 0xa1, 0xcf, 0x87, 0x2c, 0x74, 0x3c, 0x57, + 0x63, 0xb3, 0xb2, 0x9c, 0xcd, 0x96, 0x24, 0xaa, 0x25, 0x34, 0x31, 0xc7, 0x5d, 0x28, 0x0e, 0x78, + 0xd0, 0xf7, 0x9d, 0x89, 0x00, 0x57, 0xf3, 0x52, 0x11, 0x1a, 0x88, 0x7c, 0x06, 0xdb, 0x4b, 0xcf, + 0xb6, 0x5c, 0xb1, 0xb0, 0x9b, 0xde, 0xcb, 0xd2, 0x7b, 0x4b, 0x0e, 0x38, 0xb2, 0xff, 0x10, 0xf2, + 0x6c, 0x7a, 0x25, 0x4f, 0x36, 0xe8, 0xc2, 0xc5, 0x11, 0x94, 0xae, 0xb0, 0xe9, 0x15, 0x86, 0xd2, + 0x3d, 0x30, 0x7d, 0x1e, 0x32, 0xc7, 0xe5, 0x03, 0x5b, 0xf8, 0x55, 0xc8, 0x86, 0xd5, 0x22, 0xca, + 0x53, 0x8e, 0xe0, 0x74, 0xea, 0xf6, 0xd8, 0x90, 0x3c, 0x82, 0xf2, 0xf9, 0xd4, 0x19, 0x0d, 0x6c, + 0x67, 0x60, 0xcb, 0xa0, 0x58, 0x12, 0x78, 0x07, 0x50, 0xbf, 0x14, 0x21, 0x4f, 0x08, 0x46, 0x4b, + 0x88, 0xd1, 0x1c, 0x60, 0x10, 0x25, 0x9f, 0xc1, 0x7a, 0x4c, 0x31, 0xf5, 0x47, 0xf6, 0x85, 0xe7, + 0x8f, 0x59, 0x58, 0x5d, 0x45, 0xb2, 0xd2, 0x65, 0x18, 0x4e, 0x0e, 0x1e, 0x3e, 0xec, 0x8f, 0x1e, + 0xde, 0x1f, 0x50, 0x53, 0x11, 0x9e, 0xf9, 0xa3, 0x63, 0xc4, 0xb2, 0x06, 0xb0, 0x4a, 0xa7, 0x6e, + 0xcd, 0x75, 0xbd, 0x10, 0x95, 0xf7, 0x6d, 0xee, 0xb0, 0x39, 0x3d, 0xa7, 0x17, 0xf4, 0x6c, 0xfd, + 0x65, 0x0e, 0x56, 0xd4, 0xc1, 0xb9, 0x9d, 0xaf, 0xdf, 0x03, 0x71, 0xbe, 0xb4, 0x78, 0x9c, 0xf3, + 0xa7, 0xae, 0x98, 0x78, 0x1f, 0x4a, 0xa1, 0x33, 0xe6, 0x41, 0xc8, 0xc6, 0x13, 0x7b, 0x1c, 0xe0, + 0x62, 0x06, 0x2d, 0xc6, 0xb0, 0x56, 0x40, 0xb6, 0x20, 0x1f, 0xe9, 0xa3, 0x4a, 0x76, 0x8d, 0xbd, + 0x34, 0x5d, 0x51, 0xdb, 0x26, 0x1f, 0x81, 0x39, 0x98, 0xfa, 0xd2, 0xb3, 0x04, 0x89, 0xe0, 0x20, + 0x82, 0xb2, 0x71, 0x60, 0x3c, 0xa2, 0xe5, 0x68, 0xaa, 0xe7, 0x8c, 0x79, 0x2b, 0x10, 0x57, 0x5d, + 0xc8, 0x86, 0x41, 0x35, 0x8b, 0xe7, 0x03, 0xbf, 0xc9, 0x1f, 0x83, 0x8a, 0xdb, 0x36, 0x5e, 0x40, + 0xba, 0x83, 0x13, 0x69, 0x7c, 0xfd, 0x62, 0xa3, 0x15, 0x89, 0x8c, 0x03, 0xf4, 0x99, 0x9f, 0x42, + 0x21, 0xf2, 0x6e, 0x5e, 0x5d, 0xd1, 0xcf, 0x54, 0xe4, 0xc0, 0x9c, 0x26, 0x18, 0xe4, 0x0f, 0xa0, + 0x2c, 0x63, 0xcb, 0x0b, 0x7e, 0x2d, 0xd7, 0xca, 0xa3, 0x30, 0x25, 0x84, 0x3e, 0xe7, 0xd7, 0xcb, + 0xfc, 0xbc, 0xb0, 0xe8, 0xe7, 0x9f, 0x43, 0x85, 0xc5, 0x26, 0x96, 0x8c, 0xa4, 0xc7, 0xae, 0xc7, + 0x41, 0x2d, 0x71, 0x01, 0x5a, 0x4e, 0x70, 0x91, 0xff, 0x3b, 0x00, 0x97, 0xde, 0x4b, 0xee, 0xdb, + 0x21, 0xbf, 0x0a, 0xab, 0x15, 0x64, 0x5f, 0x40, 0x48, 0x8f, 0x5f, 0x85, 0xe4, 0x63, 0x28, 0x86, + 0x3c, 0x08, 0x6d, 0x6f, 0x1a, 0x4e, 0xa6, 0x21, 0xba, 0x6b, 0x71, 0xdf, 0x94, 0x8c, 0x7b, 0x3c, + 0x08, 0x3b, 0x08, 0xa7, 0x10, 0xc6, 0xdf, 0xe4, 0x31, 0x94, 0x2f, 0xaf, 0x27, 0xdc, 0x1f, 0x39, + 0xd1, 0x59, 0x5b, 0x5d, 0x7e, 0x80, 0x56, 0x63, 0xb4, 0x85, 0x23, 0x67, 0xbe, 0xe1, 0xc8, 0xed, + 0x42, 0x09, 0xc5, 0x9a, 0xb0, 0x20, 0x10, 0xae, 0xb0, 0x86, 0x72, 0xa3, 0x14, 0xa7, 0x2c, 0x08, + 0x9a, 0x03, 0x72, 0x00, 0xa6, 0x14, 0x7c, 0x92, 0xa8, 0xa5, 0x8c, 0x5c, 0x75, 0xe9, 0x27, 0x52, + 0x27, 0x61, 0xfc, 0x2d, 0x24, 0x79, 0x96, 0xc9, 0x17, 0xcd, 0x12, 0xdd, 0x19, 0xf0, 0x89, 0xcf, + 0xfb, 0x2c, 0xe4, 0x03, 0x9b, 0xb9, 0x6c, 0x74, 0xfd, 0x8a, 0xfb, 0xb6, 0xcf, 0x83, 0xe9, 0x28, + 0x0c, 0xa8, 0x39, 0x0f, 0xb1, 0x7e, 0x97, 0x82, 0xa2, 0xbc, 0x13, 0x4e, 0x3d, 0xc7, 0x0d, 0xc9, + 0x7b, 0x50, 0xd4, 0x02, 0xad, 0xca, 0x9a, 0x20, 0x09, 0xa9, 0xe4, 0x73, 0x58, 0x53, 0xe1, 0x54, + 0x9e, 0x49, 0x14, 0x31, 0xa5, 0x8b, 0x98, 0xa4, 0x7b, 0xb4, 0x22, 0x51, 0x71, 0x80, 0xda, 0x6a, + 0xc3, 0xbd, 0x00, 0x57, 0xb3, 0x13, 0x83, 0x06, 0xfa, 0x35, 0x75, 0x57, 0xbf, 0xa6, 0x34, 0x07, + 0xd8, 0x0c, 0xe6, 0x20, 0x81, 0xba, 0x17, 0x12, 0xed, 0x67, 0x90, 0xc1, 0xbb, 0x3a, 0x03, 0xdc, + 0xd3, 0x83, 0x9a, 0x54, 0x7f, 0xc3, 0x0d, 0xfd, 0xeb, 0xd8, 0x18, 0xdb, 0x07, 0x50, 0xd2, 0x27, + 0x44, 0x4e, 0x98, 0x1c, 0x7d, 0xf1, 0x39, 0x9b, 0x8f, 0x96, 0x54, 0x3e, 0x7a, 0x90, 0xfa, 0xb9, + 0x61, 0x0d, 0xc1, 0x9c, 0x97, 0x90, 0x6c, 0x40, 0x06, 0x9d, 0x11, 0x19, 0x3c, 0xbd, 0x43, 0x71, + 0x44, 0x1e, 0x42, 0x21, 0xf6, 0x17, 0x75, 0x6b, 0xcf, 0xfb, 0xc7, 0xd3, 0x3b, 0x34, 0xc1, 0x39, + 0x2c, 0x01, 0x24, 0xaa, 0xb1, 0x5e, 0x46, 0xd6, 0x69, 0xf8, 0xbe, 0xe7, 0xbf, 0xd9, 0x3a, 0xef, + 0x43, 0x49, 0x2a, 0xca, 0xd7, 0xaf, 0xe3, 0xa2, 0x82, 0xe1, 0x4d, 0xfb, 0x01, 0xac, 0x72, 0xc1, + 0x2c, 0x2e, 0x55, 0x64, 0x70, 0x2c, 0x21, 0x50, 0x15, 0x19, 0xd6, 0xff, 0x19, 0xd1, 0xc2, 0x98, + 0x2a, 0xfc, 0x9e, 0x11, 0x72, 0x07, 0x0a, 0x71, 0xcc, 0x50, 0xcb, 0xe5, 0xa3, 0x70, 0x41, 0xfe, + 0x08, 0xd6, 0x94, 0x4b, 0x4c, 0x84, 0xb5, 0x92, 0x04, 0x60, 0x2e, 0x67, 0x41, 0x5b, 0xd2, 0x4a, + 0x90, 0x0c, 0xd0, 0x03, 0x12, 0x72, 0xb9, 0x2b, 0x24, 0xcf, 0x2e, 0x92, 0xa3, 0x02, 0x23, 0x72, + 0x1c, 0x60, 0xe2, 0xf3, 0x2f, 0x29, 0xa8, 0xb4, 0xd0, 0x49, 0xe3, 0x68, 0x27, 0x82, 0x8b, 0x72, + 0xf1, 0x64, 0xa7, 0x05, 0x09, 0x11, 0x02, 0x9b, 0x90, 0x1e, 0x3b, 0x6e, 0x54, 0x3c, 0x8c, 0x1d, + 0x17, 0x21, 0xec, 0x4a, 0x05, 0x7e, 0xf1, 0x29, 0x02, 0xf5, 0x98, 0x33, 0x57, 0x46, 0x72, 0x8a, + 0xdf, 0xe4, 0x2e, 0xe4, 0xc6, 0x7c, 0xe0, 0x30, 0x17, 0x33, 0x17, 0x83, 0xaa, 0x11, 0xf9, 0x29, + 0x90, 0x20, 0x64, 0xee, 0x80, 0xf9, 0x03, 0x7b, 0xc0, 0x5f, 0x3a, 0x68, 0xf9, 0x6a, 0x0e, 0x71, + 0xd6, 0xa2, 0x99, 0xa3, 0x68, 0x82, 0x1c, 0xc0, 0x96, 0x24, 0xb4, 0xd9, 0x79, 0xe0, 0x8d, 0xa6, + 0x21, 0xd7, 0xa8, 0x0a, 0x48, 0x75, 0x4f, 0x22, 0xd4, 0xd4, 0x7c, 0x42, 0xfb, 0x63, 0xa8, 0x68, + 0xc9, 0x45, 0x9c, 0xc3, 0x18, 0xb4, 0x9c, 0x80, 0x51, 0xab, 0x1b, 0x90, 0xed, 0x7b, 0x53, 0x37, + 0xc4, 0x0c, 0x25, 0x4d, 0xe5, 0xc0, 0xfa, 0xbb, 0x14, 0x94, 0x44, 0x5c, 0x8e, 0x35, 0xf5, 0x00, + 0xd6, 0xa7, 0x01, 0x3b, 0x1f, 0x71, 0x5b, 0xd9, 0x40, 0x12, 0x19, 0x48, 0xb4, 0x26, 0xa7, 0xa4, + 0xfa, 0xeb, 0x62, 0x82, 0x7c, 0x1c, 0x17, 0x21, 0x33, 0xf8, 0x42, 0x95, 0x69, 0x71, 0xdf, 0xa9, + 0x9b, 0x4c, 0x27, 0x79, 0x08, 0x44, 0x1a, 0x76, 0x86, 0x22, 0x1d, 0x51, 0x98, 0x38, 0xa9, 0x13, + 0x7c, 0x08, 0x95, 0xc4, 0x55, 0x83, 0xbe, 0xe7, 0x73, 0xb4, 0x42, 0x16, 0xef, 0xd3, 0x78, 0xa6, + 0x2b, 0x26, 0xc8, 0x11, 0x6c, 0xce, 0x25, 0x78, 0x5c, 0x77, 0xa0, 0xc5, 0x80, 0xb6, 0x3e, 0x9b, + 0xda, 0xa1, 0xb2, 0xac, 0xff, 0x36, 0xa0, 0x90, 0xe8, 0xa4, 0x09, 0x9b, 0xca, 0x7b, 0xe6, 0x78, + 0x1a, 0xc8, 0x73, 0x53, 0xf2, 0x9c, 0xf3, 0x39, 0xba, 0x3e, 0x9e, 0x05, 0xa0, 0x15, 0xfe, 0x10, + 0x56, 0xc5, 0x81, 0x4a, 0xae, 0x67, 0x19, 0x40, 0x48, 0x72, 0x43, 0xc6, 0xf4, 0x25, 0x5f, 0xb7, + 0xcb, 0xeb, 0x93, 0xc8, 0xf4, 0x6b, 0x93, 0x48, 0xeb, 0xbf, 0x0c, 0x20, 0x33, 0xb5, 0xc0, 0x17, + 0x53, 0xee, 0x5f, 0x0b, 0xf7, 0xed, 0x4f, 0xfd, 0xc0, 0xf3, 0xd5, 0x89, 0x50, 0x23, 0x4c, 0xc0, + 0x9c, 0xb1, 0x23, 0xad, 0x98, 0xa5, 0x72, 0xb0, 0x18, 0x30, 0xd2, 0xb7, 0x2a, 0x1f, 0x32, 0xb7, + 0x29, 0x1f, 0xb2, 0x8b, 0xe5, 0xc3, 0x06, 0x64, 0xb1, 0x58, 0xc0, 0x63, 0x53, 0xa0, 0x72, 0x60, + 0xfd, 0xd6, 0x80, 0xed, 0xc5, 0x9d, 0x50, 0x1e, 0x4c, 0x3c, 0x37, 0x10, 0xa9, 0x4c, 0x2e, 0xc0, + 0x46, 0x8e, 0x2a, 0xc2, 0x4a, 0x7a, 0x73, 0x87, 0xaa, 0x39, 0x6d, 0xdf, 0xa9, 0x99, 0x7d, 0xd7, + 0x61, 0x7d, 0xb6, 0x94, 0xd3, 0x23, 0xd7, 0xd2, 0x7a, 0x6e, 0x6d, 0xa6, 0x9e, 0x43, 0x5d, 0xff, + 0x63, 0x1a, 0x4f, 0xd4, 0xf7, 0xaa, 0x65, 0x2d, 0x2c, 0x67, 0x66, 0xc2, 0xf2, 0x7c, 0x3a, 0x52, + 0x5c, 0x48, 0x47, 0x1e, 0x43, 0x41, 0x90, 0x7a, 0xfe, 0x80, 0xfb, 0x18, 0x0a, 0xca, 0xfb, 0xe5, + 0xd8, 0xf9, 0x3a, 0x02, 0x7a, 0x90, 0x34, 0x7b, 0xa8, 0x28, 0x4f, 0x11, 0x28, 0x6a, 0x8b, 0xb1, + 0x23, 0xf3, 0xd9, 0x38, 0x2d, 0x96, 0x41, 0xaf, 0x3c, 0x76, 0x30, 0x99, 0x8d, 0x32, 0x63, 0x81, + 0xc9, 0xae, 0x66, 0x31, 0x73, 0x0a, 0x93, 0x5d, 0xe9, 0x98, 0xbb, 0x50, 0x12, 0x3c, 0xe3, 0x3c, + 0xba, 0x80, 0x41, 0x06, 0xc6, 0x8e, 0x7b, 0xa8, 0x52, 0x69, 0x81, 0xc1, 0xae, 0x12, 0x0c, 0x50, + 0x18, 0xec, 0x2a, 0xc2, 0x88, 0xf2, 0xe7, 0x15, 0x2d, 0x7f, 0xbe, 0x0b, 0xb9, 0x0b, 0x87, 0x8f, + 0x06, 0x41, 0xb5, 0x84, 0x50, 0x35, 0xb2, 0xfe, 0xca, 0x80, 0x0d, 0xdd, 0x34, 0xdf, 0x91, 0xdb, + 0x7c, 0x2c, 0xcf, 0xf4, 0xbc, 0xc3, 0xcc, 0x95, 0xf2, 0x45, 0x55, 0xca, 0xa3, 0x93, 0xfc, 0xc6, + 0x88, 0xd2, 0x0d, 0xbc, 0x8c, 0x7f, 0x78, 0x47, 0x99, 0xb9, 0xbf, 0xb3, 0xb3, 0xf7, 0xb7, 0xf5, + 0x0f, 0x06, 0x54, 0xe7, 0xa5, 0xfb, 0x8e, 0x74, 0x95, 0xdc, 0xed, 0x5a, 0x3b, 0x23, 0x73, 0x53, + 0x3b, 0x43, 0xdd, 0xed, 0x87, 0x71, 0x53, 0xe3, 0x19, 0x98, 0x75, 0x9f, 0xcb, 0xfc, 0xf1, 0xed, + 0x04, 0x52, 0xb9, 0x60, 0x2a, 0xce, 0x05, 0x2d, 0x0a, 0x1b, 0x2d, 0x6f, 0xe0, 0x5c, 0x38, 0xfd, + 0x6f, 0xc3, 0x2f, 0xbe, 0x4e, 0x53, 0xfa, 0x75, 0xfa, 0x1c, 0x56, 0xf1, 0xca, 0xfa, 0x4e, 0x98, + 0x35, 0x60, 0xbb, 0xcb, 0xfb, 0x9e, 0x48, 0x16, 0xae, 0xbb, 0xa1, 0xe7, 0xb3, 0x21, 0xff, 0xca, + 0x77, 0x42, 0xde, 0x14, 0xc9, 0x21, 0xf9, 0x31, 0xe4, 0xce, 0xb1, 0x03, 0xa5, 0x38, 0x57, 0x62, + 0x77, 0x93, 0x8d, 0x29, 0xaa, 0xa6, 0xad, 0x5f, 0xc1, 0xce, 0x52, 0x36, 0xaa, 0x4a, 0xba, 0x9d, + 0x84, 0xf7, 0x85, 0x0f, 0xba, 0x2f, 0x02, 0x55, 0x17, 0x2c, 0x14, 0x44, 0x72, 0xd6, 0xfa, 0x9d, + 0x01, 0x95, 0xe8, 0xce, 0xf2, 0x7c, 0x29, 0xe8, 0x0f, 0xd3, 0x20, 0x3b, 0x00, 0x53, 0x39, 0xd6, + 0x45, 0x9c, 0x08, 0xa5, 0xf5, 0x2b, 0x5f, 0xfa, 0xd5, 0xb1, 0x33, 0xe2, 0xb4, 0x1c, 0xc4, 0xdf, + 0xe8, 0x55, 0x35, 0x30, 0x13, 0xa1, 0x95, 0x5a, 0x66, 0x6a, 0x68, 0xe3, 0x4d, 0x35, 0xb4, 0xf5, + 0xd7, 0x29, 0x30, 0x8f, 0xbc, 0x6f, 0x5c, 0x95, 0x96, 0xcb, 0x9d, 0xeb, 0xd2, 0x1b, 0x6f, 0x2d, + 0x7d, 0xea, 0x76, 0xd2, 0x93, 0x9f, 0xc1, 0xdd, 0x99, 0xf2, 0x0d, 0x9d, 0xc7, 0x16, 0xd9, 0x6b, + 0x0e, 0xbd, 0x69, 0x5d, 0xab, 0xd8, 0xd0, 0x39, 0x5b, 0xec, 0x4a, 0x10, 0xcd, 0xe4, 0xd8, 0x09, + 0x51, 0x46, 0x12, 0x69, 0x59, 0x75, 0x4c, 0x14, 0x37, 0x0a, 0x02, 0xe7, 0x15, 0x47, 0xe4, 0x2c, + 0x22, 0xcb, 0x46, 0x41, 0xd7, 0x79, 0xc5, 0x5b, 0xec, 0xca, 0xa2, 0xb0, 0xa6, 0x69, 0x42, 0xa9, + 0x73, 0xe9, 0xb9, 0x37, 0x6e, 0x7d, 0xee, 0xff, 0xc2, 0x80, 0xed, 0x9a, 0x2a, 0x74, 0x9f, 0x3a, + 0x41, 0xe8, 0xf9, 0x4e, 0x1f, 0xc3, 0xd2, 0x0f, 0xe8, 0x62, 0xd6, 0xff, 0xa4, 0x61, 0x67, 0xa9, + 0x10, 0x6f, 0x75, 0x92, 0x6a, 0xb0, 0x1e, 0xdf, 0x16, 0x7f, 0x2e, 0xa8, 0x75, 0x6b, 0x93, 0x99, + 0xa5, 0x65, 0xe0, 0x35, 0x7d, 0x6d, 0x84, 0x16, 0xbf, 0x0f, 0xc5, 0x21, 0x0f, 0xa5, 0x26, 0x79, + 0xa0, 0x1e, 0x9f, 0x64, 0xc3, 0x1f, 0x86, 0x3c, 0x3c, 0x94, 0x70, 0xd2, 0x07, 0x32, 0xb7, 0xd2, + 0x98, 0x4d, 0x54, 0xb0, 0x7d, 0xac, 0x7c, 0xf9, 0xe6, 0xed, 0xcc, 0x08, 0xd1, 0x62, 0x13, 0x59, + 0x6b, 0x57, 0xfc, 0x59, 0xe8, 0x76, 0x17, 0xca, 0x1a, 0xa2, 0xc3, 0x6f, 0xdc, 0xa0, 0x71, 0xfb, + 0x0d, 0x6e, 0x87, 0xb3, 0xf7, 0x74, 0xb4, 0xfa, 0x92, 0x82, 0xfe, 0x58, 0x2f, 0xe8, 0x8b, 0xfb, + 0x8f, 0xde, 0x6a, 0x5b, 0x0e, 0x0f, 0xf4, 0x16, 0xc0, 0x6f, 0xd2, 0xb0, 0x1a, 0x51, 0x4a, 0xbf, + 0xfa, 0x5c, 0x6a, 0x30, 0xf4, 0xec, 0x73, 0x1e, 0xb5, 0x5e, 0x06, 0x37, 0xc5, 0x5b, 0xa1, 0x9a, + 0x9e, 0x77, 0xc8, 0x15, 0x8b, 0x01, 0xf9, 0x05, 0xac, 0x5f, 0x2a, 0x01, 0xd8, 0x08, 0x1b, 0xb2, + 0x9a, 0xa5, 0x17, 0xc8, 0xd7, 0x12, 0x5c, 0x3a, 0x95, 0x2d, 0xb1, 0xaf, 0x80, 0xcc, 0x31, 0x10, + 0x06, 0x94, 0x51, 0xed, 0x27, 0xb3, 0x3b, 0x45, 0x79, 0x1f, 0x3c, 0xd5, 0x59, 0xc4, 0x36, 0x33, + 0x2f, 0xe7, 0xc0, 0xdb, 0x2d, 0x80, 0x78, 0xe1, 0xe0, 0x26, 0x39, 0x8d, 0xdb, 0xca, 0xb9, 0xdd, + 0x87, 0xcd, 0xa5, 0x2b, 0x2f, 0xb1, 0xd7, 0x27, 0xb3, 0xf6, 0x7a, 0x77, 0xd9, 0x2e, 0x12, 0xd1, + 0x74, 0xeb, 0xfc, 0x6f, 0x1a, 0xca, 0x11, 0xde, 0x5b, 0x1d, 0xb8, 0x77, 0x01, 0x7c, 0x3e, 0xf4, + 0x79, 0x10, 0x88, 0x72, 0x5a, 0xac, 0x9b, 0xa7, 0x1a, 0x44, 0xcf, 0x91, 0x56, 0xe6, 0xbb, 0xc0, + 0x68, 0xf3, 0xc0, 0x09, 0x70, 0x56, 0xb5, 0xf6, 0x23, 0x98, 0x40, 0x79, 0x06, 0x1b, 0x31, 0x4a, + 0xe8, 0x3b, 0x6c, 0xa8, 0x1e, 0x32, 0x00, 0xe5, 0xa9, 0x6a, 0xbb, 0x0b, 0x9c, 0xa0, 0x87, 0x08, + 0x18, 0x53, 0x08, 0x5b, 0x80, 0x89, 0xe5, 0x64, 0x27, 0xa8, 0xef, 0xb9, 0x17, 0xce, 0x50, 0xd5, + 0x3d, 0xb2, 0x3b, 0x54, 0x47, 0x10, 0x79, 0x0c, 0xf7, 0x02, 0xee, 0x3b, 0x6c, 0xe4, 0xbc, 0xe2, + 0x03, 0x7b, 0x06, 0xbb, 0x88, 0x0d, 0xad, 0xcd, 0x64, 0xba, 0xa9, 0xd1, 0xdd, 0x85, 0x9c, 0xea, + 0x9b, 0xca, 0x24, 0x51, 0x8d, 0xc8, 0x47, 0xb0, 0xa6, 0xf1, 0xd3, 0x5a, 0xab, 0x25, 0x6a, 0x26, + 0x13, 0x4a, 0xdb, 0x1f, 0xc0, 0x6a, 0xdc, 0x6b, 0xc4, 0xb7, 0x4f, 0x99, 0x51, 0x96, 0x22, 0x20, + 0x3e, 0x28, 0xea, 0x48, 0x5a, 0x65, 0x17, 0x23, 0x89, 0x8c, 0xe1, 0x59, 0x26, 0x5f, 0x30, 0x81, + 0x6e, 0xf4, 0xf1, 0xad, 0x41, 0xb6, 0x88, 0x94, 0x05, 0x02, 0x11, 0x64, 0xc9, 0xa2, 0xc2, 0x08, + 0x85, 0x72, 0xac, 0x68, 0x61, 0xd7, 0xe8, 0xe5, 0xf5, 0xa3, 0x9b, 0x54, 0x3c, 0x07, 0xc2, 0xb7, + 0xd8, 0xd5, 0x88, 0x85, 0xf0, 0x10, 0x4e, 0x9e, 0x41, 0x91, 0xbb, 0x2f, 0x1d, 0xdf, 0x73, 0xc7, + 0x5c, 0xe5, 0x5e, 0xe5, 0xfd, 0xbd, 0x1b, 0x19, 0x36, 0x12, 0x5c, 0xe4, 0xa6, 0x13, 0x93, 0x2a, + 0xac, 0xf4, 0xbd, 0x31, 0xf2, 0x91, 0x2a, 0x8e, 0x86, 0xc2, 0xac, 0xe7, 0xd3, 0x21, 0x73, 0x1d, + 0xa1, 0x12, 0x67, 0xa0, 0xb4, 0x56, 0x8c, 0x61, 0xcd, 0x81, 0xee, 0x81, 0xd9, 0xd7, 0x7a, 0x60, + 0x6e, 0xc1, 0x03, 0xad, 0x5f, 0xce, 0xab, 0x0b, 0xcd, 0x90, 0x87, 0x4c, 0xbb, 0xd3, 0x6e, 0x98, + 0x77, 0x48, 0x19, 0x80, 0x36, 0x9e, 0xd0, 0x46, 0xb7, 0xdb, 0xec, 0xb4, 0x4d, 0x83, 0x00, 0xe4, + 0x9a, 0x4f, 0xda, 0x1d, 0xda, 0x30, 0x53, 0x84, 0x40, 0xf9, 0xb8, 0x76, 0xd2, 0x6d, 0xd8, 0xa7, + 0x9d, 0x6e, 0xb3, 0xd7, 0xfc, 0xb2, 0x61, 0xa6, 0x49, 0x11, 0x56, 0xce, 0xda, 0xcf, 0xdb, 0x9d, + 0xaf, 0xda, 0x66, 0xc6, 0xfa, 0x02, 0x2a, 0x73, 0xbb, 0x26, 0x15, 0x28, 0x9e, 0xb5, 0xbb, 0xa7, + 0x8d, 0x7a, 0xf3, 0xb8, 0xd9, 0x38, 0x32, 0xef, 0x90, 0x55, 0x28, 0x9c, 0xd2, 0x46, 0xf7, 0xec, + 0xb0, 0xd5, 0xec, 0x99, 0x86, 0x58, 0xef, 0xb4, 0xd3, 0xed, 0xa9, 0x71, 0x0a, 0xc7, 0xb4, 0x73, + 0x74, 0x56, 0xef, 0x89, 0xf5, 0xd3, 0xd6, 0xbf, 0xa7, 0xe1, 0x47, 0x47, 0x2c, 0xb8, 0x3c, 0xf7, + 0x98, 0x3f, 0x88, 0x53, 0xa9, 0xfa, 0x25, 0xf3, 0x43, 0x19, 0x73, 0x6f, 0xd5, 0x97, 0xfc, 0x0c, + 0x4c, 0x99, 0xec, 0x04, 0x7c, 0xc4, 0xfb, 0xd8, 0x3c, 0x9e, 0xcd, 0x97, 0x92, 0xa7, 0x78, 0x5a, + 0x41, 0xcc, 0x6e, 0x8c, 0x18, 0x97, 0x8c, 0x69, 0xad, 0x64, 0xfc, 0x2e, 0xcb, 0xe2, 0xcc, 0xad, + 0xcb, 0xe2, 0xec, 0xf7, 0x56, 0x16, 0x6f, 0x41, 0x5e, 0x60, 0xf8, 0x53, 0x57, 0x16, 0xdf, 0x59, + 0xba, 0x32, 0x66, 0x57, 0x74, 0xea, 0x06, 0xe4, 0x53, 0xd8, 0xba, 0x74, 0x86, 0x97, 0x23, 0x67, + 0x78, 0x19, 0xda, 0x01, 0xde, 0x82, 0xb6, 0xe7, 0xda, 0xf8, 0xd4, 0x82, 0x11, 0x30, 0x4f, 0xef, + 0xc6, 0x08, 0x5d, 0x9c, 0xef, 0xb8, 0x4f, 0xc5, 0xac, 0xf5, 0x6b, 0x03, 0xee, 0xc6, 0xc6, 0xa3, + 0x53, 0x57, 0x33, 0x9b, 0xe6, 0xc3, 0xc6, 0x8c, 0x0f, 0xbf, 0x07, 0xc5, 0xa4, 0xf5, 0x2a, 0xad, + 0x54, 0xa0, 0x10, 0xf7, 0x5e, 0xdf, 0x20, 0x4f, 0xfa, 0xb5, 0xf2, 0xfc, 0x67, 0x1a, 0x3e, 0x88, + 0xe5, 0xa9, 0x7b, 0xe3, 0x09, 0xf3, 0xf9, 0x32, 0x9f, 0xfa, 0x02, 0x8a, 0x8a, 0xb1, 0x76, 0xb3, + 0x3d, 0x8a, 0x3c, 0xe5, 0x8d, 0xf4, 0x0f, 0xe4, 0xaa, 0x14, 0x24, 0x13, 0xbc, 0x9b, 0x97, 0x19, + 0x3e, 0x75, 0x6b, 0xc3, 0xa7, 0x97, 0x1a, 0x5e, 0x37, 0x5a, 0xe6, 0x2d, 0x8c, 0x96, 0x7d, 0x9d, + 0x92, 0xb6, 0x7f, 0x6b, 0x40, 0x4e, 0x42, 0xf0, 0x2d, 0x41, 0xe9, 0x41, 0xfb, 0x13, 0x46, 0xe9, + 0x46, 0xbe, 0xf3, 0x2e, 0x1c, 0xbf, 0xd4, 0x92, 0xe3, 0xf7, 0x29, 0x54, 0xe6, 0x8e, 0x1f, 0xee, + 0x68, 0xd9, 0xe9, 0x2b, 0xcf, 0x9e, 0xbe, 0xf8, 0xf0, 0x65, 0x92, 0xc3, 0x67, 0xfd, 0xbd, 0x01, + 0xef, 0xcc, 0x9b, 0x61, 0xd6, 0xbb, 0xb6, 0x64, 0x92, 0x8e, 0x1e, 0x64, 0x20, 0xe5, 0x8a, 0x74, + 0xaf, 0xe0, 0x7b, 0xf5, 0xaf, 0x3f, 0x83, 0xf7, 0x62, 0xb9, 0xbe, 0x74, 0x82, 0x29, 0xde, 0x87, + 0x51, 0xb8, 0x7d, 0x83, 0xdf, 0xcf, 0xc7, 0xee, 0xd4, 0x62, 0xec, 0x7e, 0x0c, 0x90, 0x3c, 0xfe, + 0x2d, 0xfd, 0x11, 0x6a, 0xe6, 0xbd, 0xaa, 0x10, 0xfd, 0x3f, 0xf5, 0xaf, 0x69, 0x28, 0x08, 0xc2, + 0xb7, 0x08, 0x98, 0x5b, 0x90, 0x0f, 0xf9, 0x78, 0x62, 0x0f, 0x9c, 0xa8, 0x23, 0xb3, 0x22, 0xc6, + 0x47, 0x0e, 0xbe, 0x40, 0x09, 0xdf, 0xf4, 0xa6, 0x42, 0x3b, 0x7d, 0xe5, 0x9a, 0xa0, 0x40, 0x5d, + 0xde, 0x5f, 0xfa, 0x82, 0x99, 0xb9, 0xdd, 0x0b, 0x66, 0x6c, 0xee, 0x9c, 0x16, 0x6b, 0xe7, 0x9b, + 0x94, 0x2b, 0x0b, 0x4d, 0x4a, 0xfd, 0x71, 0x3d, 0x3f, 0xfb, 0xb8, 0xfe, 0xa7, 0xb0, 0xe9, 0xb8, + 0x21, 0xf7, 0x5d, 0x36, 0xb2, 0x35, 0xa9, 0x02, 0xf5, 0xd4, 0xbc, 0x97, 0x48, 0x24, 0x8f, 0x6e, + 0x53, 0x21, 0x27, 0x32, 0x06, 0x32, 0x2b, 0x5e, 0x77, 0x16, 0x67, 0xb6, 0x8f, 0xa1, 0x7a, 0x13, + 0xc1, 0x9b, 0x5e, 0x13, 0x0b, 0x5a, 0xb2, 0xfa, 0x2c, 0x93, 0xcf, 0x9a, 0x39, 0x5a, 0xc6, 0x5f, + 0xd3, 0xe4, 0x3f, 0x00, 0x01, 0xef, 0x5b, 0xff, 0x9c, 0x51, 0x06, 0x97, 0x09, 0xd5, 0xe7, 0xea, + 0x49, 0x5b, 0xcb, 0x61, 0xcb, 0xfb, 0x3b, 0xf3, 0x4f, 0xda, 0xf8, 0xa9, 0x52, 0x5a, 0xd4, 0x91, + 0xfa, 0x8b, 0xf1, 0x58, 0xa5, 0x9e, 0x22, 0xad, 0x90, 0x99, 0x9b, 0x5e, 0x5e, 0x6c, 0xcc, 0x26, + 0xd6, 0xea, 0x75, 0x9c, 0xb0, 0x99, 0xb1, 0x2a, 0x26, 0xcb, 0xc1, 0x74, 0x3c, 0x66, 0xfe, 0xb5, + 0x3d, 0x93, 0x23, 0xae, 0x2a, 0x68, 0x9c, 0x6b, 0x97, 0x85, 0x9f, 0xf7, 0xc5, 0x99, 0xb4, 0xf1, + 0xe9, 0x53, 0xa5, 0x7f, 0xbe, 0x3a, 0xa8, 0x27, 0x8e, 0xfb, 0xe2, 0xe6, 0x4c, 0xe6, 0x97, 0x70, + 0x17, 0xff, 0x8a, 0xc4, 0x97, 0xa5, 0x0b, 0xe6, 0x8c, 0xa6, 0x3e, 0x97, 0x59, 0x64, 0x0e, 0xb7, + 0x7d, 0x7f, 0x61, 0xdb, 0x34, 0x42, 0x3f, 0x96, 0xd8, 0x98, 0x73, 0x6d, 0xf8, 0x4b, 0xa0, 0xd6, + 0xd7, 0x52, 0xad, 0x4a, 0x31, 0x79, 0xc8, 0x9c, 0xd6, 0xba, 0x5d, 0xf9, 0xdf, 0x22, 0xad, 0xf5, + 0x1a, 0x36, 0xfe, 0x46, 0x89, 0xa9, 0xc8, 0x71, 0xad, 0x57, 0x3b, 0x91, 0xe3, 0x34, 0x59, 0x83, + 0xd5, 0x5a, 0xbb, 0x76, 0xf2, 0x75, 0xb7, 0xd9, 0x95, 0xa0, 0x8c, 0xc8, 0x6e, 0x9a, 0x6d, 0xfb, + 0x94, 0x76, 0x30, 0x63, 0x32, 0xb3, 0x56, 0x00, 0x1b, 0xcb, 0x04, 0x21, 0x5b, 0xb0, 0xa9, 0xd2, + 0x24, 0xbb, 0x43, 0xed, 0xb3, 0x76, 0xb7, 0xd1, 0xb3, 0x7b, 0x5f, 0x9f, 0x8a, 0x8c, 0x8b, 0x40, + 0xb9, 0x55, 0xeb, 0xf6, 0x1a, 0xd4, 0xa6, 0x22, 0x5d, 0xa0, 0x22, 0x2b, 0xba, 0x07, 0xeb, 0xcf, + 0x3a, 0x87, 0x76, 0xab, 0xd6, 0xae, 0x3d, 0xd1, 0x26, 0x52, 0x64, 0x1d, 0x2a, 0xf2, 0x1f, 0xb4, + 0x04, 0x98, 0xb6, 0x5e, 0x41, 0x49, 0x76, 0x43, 0x28, 0xef, 0x7b, 0xfe, 0x80, 0x7c, 0x12, 0x3d, + 0x01, 0xcb, 0xf7, 0x54, 0x55, 0xed, 0x2c, 0x79, 0x4a, 0x2d, 0x6a, 0x4f, 0xa9, 0x1a, 0x15, 0xb6, + 0x78, 0x54, 0xc5, 0xb5, 0xe4, 0x05, 0xb5, 0xa8, 0xf5, 0x7a, 0xac, 0x13, 0x80, 0xa4, 0xd7, 0xb4, + 0xf0, 0xf8, 0x6c, 0x2c, 0x3e, 0x3e, 0xef, 0x40, 0x01, 0x7b, 0x56, 0x13, 0x16, 0x5e, 0x46, 0xbf, + 0x35, 0x0a, 0xc0, 0x29, 0x0b, 0x2f, 0x3f, 0xfc, 0x39, 0xe4, 0xa3, 0xfc, 0x69, 0x69, 0xe6, 0x98, + 0xfc, 0x56, 0x6a, 0x90, 0x12, 0xe4, 0x0f, 0xcf, 0x9a, 0x27, 0x47, 0x76, 0xf3, 0xc8, 0x4c, 0xfd, + 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0x67, 0x9b, 0xb9, 0xcd, 0x2b, 0x00, 0x00, +}