mirror of https://github.com/knative/pkg.git
Move mako code to pkg (#590)
* move Mako code from serving to pkg * update dependencies * add analyzer * update deps * fix a few typos
This commit is contained in:
Chi Zhang
Knative Prow Robot
parent
88bd7e5013
commit
c8328b620a
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
@ -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),
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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"
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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.
|
||||
|
||||
|
||||
420
vendor/github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto/threshold_analyzer.pb.go
generated
vendored
Executable file
420
vendor/github.com/google/mako/clients/proto/analyzers/threshold_analyzer_go_proto/threshold_analyzer.pb.go
generated
vendored
Executable file
|
|
@ -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,
|
||||
}
|
||||
495
vendor/github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto/utest_analyzer.pb.go
generated
vendored
Executable file
495
vendor/github.com/google/mako/clients/proto/analyzers/utest_analyzer_go_proto/utest_analyzer.pb.go
generated
vendored
Executable file
|
|
@ -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,
|
||||
}
|
||||
855
vendor/github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto/window_deviation.pb.go
generated
vendored
Executable file
855
vendor/github.com/google/mako/clients/proto/analyzers/window_deviation_go_proto/window_deviation.pb.go
generated
vendored
Executable file
|
|
@ -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,
|
||||
}
|
||||
301
vendor/github.com/google/mako/helpers/go/quickstore/quickstore.go
generated
vendored
Normal file
301
vendor/github.com/google/mako/helpers/go/quickstore/quickstore.go
generated
vendored
Normal file
|
|
@ -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
|
||||
}
|
||||
441
vendor/github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto/quickstore.pb.go
generated
vendored
Executable file
441
vendor/github.com/google/mako/helpers/proto/quickstore/quickstore_go_proto/quickstore.pb.go
generated
vendored
Executable file
|
|
@ -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,
|
||||
}
|
||||
|
|
@ -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
|
||||
360
vendor/github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto/quickstore.pb.go
generated
vendored
Executable file
360
vendor/github.com/google/mako/internal/quickstore_microservice/proto/quickstore_go_proto/quickstore.pb.go
generated
vendored
Executable file
|
|
@ -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",
|
||||
}
|
||||
4052
vendor/github.com/google/mako/spec/proto/mako_go_proto/mako.pb.go
generated
vendored
Executable file
4052
vendor/github.com/google/mako/spec/proto/mako_go_proto/mako.pb.go
generated
vendored
Executable file
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue