Add grpc-gateway based http json api for Tiller.

pull/2177/head
tamal 9 years ago
parent a34f2328f1
commit 27463986c1

@ -3,6 +3,8 @@ comma := ,
empty :=
import_path = k8s.io/helm/pkg/proto/hapi
go_path := $(shell go env GOPATH)
googleapis_dir := $(go_path)/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis
dst = ../pkg/proto
target = go
@ -30,16 +32,17 @@ google_deps = Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptype
all: chart release services version
chart:
PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias):$(dst) $(chart_pbs)
PATH=../bin:$(PATH) protoc -I . -I $(googleapis_dir) --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias):$(dst) $(chart_pbs)
release:
PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias):$(dst) $(release_pbs)
PATH=../bin:$(PATH) protoc -I . -I $(googleapis_dir) --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias):$(dst) $(release_pbs)
services:
PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias),$(release_ias):$(dst) $(services_pbs)
PATH=../bin:$(PATH) protoc -I . -I $(googleapis_dir) --$(target)_out=plugins=$(plugins),$(google_deps),$(chart_ias),$(version_ias),$(release_ias):$(dst) $(services_pbs)
PATH=../bin:$(PATH) protoc -I . -I $(googleapis_dir) --grpc-gateway_out=logtostderr=true,$(google_deps),$(chart_ias),$(version_ias),$(release_ias):$(dst) $(services_pbs)
version:
PATH=../bin:$(PATH) protoc --$(target)_out=plugins=$(plugins),$(google_deps):$(dst) $(version_pbs)
PATH=../bin:$(PATH) protoc -I . -I $(googleapis_dir) --$(target)_out=plugins=$(plugins),$(google_deps):$(dst) $(version_pbs)
.PHONY: clean
clean:

@ -16,6 +16,8 @@ syntax = "proto3";
package hapi.services.tiller;
import "google/api/annotations.proto";
import "hapi/chart/chart.proto";
import "hapi/chart/config.proto";
import "hapi/release/release.proto";
@ -45,42 +47,75 @@ service ReleaseService {
// release status. By default, ListAllReleases returns the releases who
// current status is "Active".
rpc ListReleases(ListReleasesRequest) returns (stream ListReleasesResponse) {
option (google.api.http) = {
get: "/tiller/v2/releases/json"
};
}
// GetReleasesStatus retrieves status information for the specified release.
rpc GetReleaseStatus(GetReleaseStatusRequest) returns (GetReleaseStatusResponse) {
option (google.api.http) = {
get: "/tiller/v2/releases/{name}/versions/{version}/status/json"
};
}
// GetReleaseContent retrieves the release content (chart + value) for the specified release.
rpc GetReleaseContent(GetReleaseContentRequest) returns (GetReleaseContentResponse) {
option (google.api.http) = {
get: "/tiller/v2/releases/{name}/versions/{version}/content/json"
};
}
// UpdateRelease updates release content.
rpc UpdateRelease(UpdateReleaseRequest) returns (UpdateReleaseResponse) {
option (google.api.http) = {
put: "/tiller/v2/releases/{name}/json"
body: "*"
};
}
// InstallRelease requests installation of a chart as a new release.
rpc InstallRelease(InstallReleaseRequest) returns (InstallReleaseResponse) {
option (google.api.http) = {
post: "/tiller/v2/releases/{name}/json"
body: "*"
};
}
// UninstallRelease requests deletion of a named release.
rpc UninstallRelease(UninstallReleaseRequest) returns (UninstallReleaseResponse) {
option (google.api.http) = {
delete : "/tiller/v2/releases/{name}/json"
};
}
// GetVersion returns the current version of the server.
rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {
option (google.api.http) = {
get: "/tiller/v2/version/json"
};
}
// RollbackRelease rolls back a release to a previous version.
rpc RollbackRelease(RollbackReleaseRequest) returns (RollbackReleaseResponse) {
option (google.api.http) = {
delete : "/tiller/v2/releases/{name}/versions/{version}/content/json"
};
}
// ReleaseHistory retrieves a releasse's history.
rpc GetHistory(GetHistoryRequest) returns (GetHistoryResponse) {
option (google.api.http) = {
get: "/tiller/v2/releases/{name}/json"
};
}
// RunReleaseTest executes the tests defined of a named release
rpc RunReleaseTest(TestReleaseRequest) returns (stream TestReleaseResponse) {
option (google.api.http) = {
post: "/tiller/v2/releases/{name}/actions/test/json"
body: "*"
};
}
}

@ -25,7 +25,10 @@ import (
"os"
"strings"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/spf13/cobra"
"golang.org/x/net/context"
"google.golang.org/grpc"
"k8s.io/helm/pkg/kube"
"k8s.io/helm/pkg/proto/hapi/services"
@ -55,6 +58,7 @@ var (
grpcAddr = ":44134"
probeAddr = ":44135"
traceAddr = ":44136"
gatewayAddr = ":44137"
enableTracing = false
store = storageConfigMap
)
@ -111,6 +115,7 @@ func start(c *cobra.Command, args []string) {
fmt.Printf("Starting Tiller %s\n", version.GetVersion())
fmt.Printf("GRPC listening on %s\n", grpcAddr)
fmt.Printf("Gateway listening on %s\n", gatewayAddr)
fmt.Printf("Probes listening on %s\n", probeAddr)
fmt.Printf("Storage driver is %s\n", env.Releases.Name())
@ -118,13 +123,31 @@ func start(c *cobra.Command, args []string) {
startTracing(traceAddr)
}
srvErrCh := make(chan error)
grpcErrCh := make(chan error)
gwErrCh := make(chan error)
probeErrCh := make(chan error)
go func() {
svc := tiller.NewReleaseServer(env, clientset)
services.RegisterReleaseServiceServer(rootServer, svc)
if err := rootServer.Serve(lstn); err != nil {
srvErrCh <- err
grpcErrCh <- err
}
}()
go func() {
ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
mux := runtime.NewServeMux(runtime.EqualFoldMatcher("x-helm-api-client"))
opts := []grpc.DialOption{grpc.WithInsecure()}
err := services.RegisterReleaseServiceHandlerFromEndpoint(ctx, mux, "localhost"+grpcAddr, opts)
if err != nil {
gwErrCh <- err
return
}
if err := http.ListenAndServe(gatewayAddr, mux); err != nil {
gwErrCh <- err
}
}()
@ -136,8 +159,11 @@ func start(c *cobra.Command, args []string) {
}()
select {
case err := <-srvErrCh:
fmt.Fprintf(os.Stderr, "Server died: %s\n", err)
case err := <-grpcErrCh:
fmt.Fprintf(os.Stderr, "gRPC server died: %s\n", err)
os.Exit(1)
case err := <-gwErrCh:
fmt.Fprintf(os.Stderr, "Gateway server died: %s\n", err)
os.Exit(1)
case err := <-probeErrCh:
fmt.Fprintf(os.Stderr, "Probes server died: %s\n", err)

36
glide.lock generated

@ -1,5 +1,5 @@
hash: 0d1c5b7304a853820dcaa296d3aa1f5f3466a8491dcef80cbcaf43c954acb2a8
updated: 2017-03-20T15:26:55.446524716-07:00
hash: dc4840b17b6bc23402af21a169321335f4fb35598f43358a582afe575f48dc58
updated: 2017-03-23T14:39:37.785507869-07:00
imports:
- name: cloud.google.com/go
version: 3b1ae45394a234c385be014e9a488f2bb6eef821
@ -99,7 +99,7 @@ imports:
- name: github.com/facebookgo/symwalk
version: 42004b9f322246749dd73ad71008b1f3160c0052
- name: github.com/ghodss/yaml
version: 04f313413ffd65ce25f2541bfd2b2ceec5c0908c
version: 73d445a93680fa1a78ae23a5839bad48f32ba1ee
- name: github.com/go-openapi/jsonpointer
version: 46af16f9f7b149af66e5d1bd010e3574dc06de98
- name: github.com/go-openapi/jsonreference
@ -153,9 +153,11 @@ imports:
subpackages:
- lru
- name: github.com/golang/protobuf
version: df1d3ca07d2d07bba352d5b73c4313b4e2a6203e
version: 24f28ae800abfde9310e779f94be606b1a98a3fc
subpackages:
- jsonpb
- proto
- protoc-gen-go/descriptor
- ptypes/any
- ptypes/timestamp
- name: github.com/google/gofuzz
@ -165,6 +167,13 @@ imports:
subpackages:
- util/strutil
- util/wordwrap
- name: github.com/grpc-ecosystem/grpc-gateway
version: ba94bf40bd539529f3ff953e6c7eb3612b4c8df6
repo: https://github.com/appscode/grpc-gateway.git
subpackages:
- runtime
- runtime/internal
- utilities
- name: github.com/howeyc/gopass
version: 3ca23474a7c7203e0a0a070fd33508f6efdb9b3d
- name: github.com/imdario/mergo
@ -186,7 +195,7 @@ imports:
- name: github.com/Masterminds/sprig
version: 23597e5f6ad0e4d590e71314bfd0251a4a3cf849
- name: github.com/mattn/go-runewidth
version: 14207d285c6c197daabb5c9793d63e7af9ab2d50
version: e882a96ec18dd43fa283187b66af74497c9101c0
- name: github.com/mitchellh/go-wordwrap
version: ad45545899c7b13c020ea92b2072220eefad42b8
- name: github.com/naoina/go-stringutil
@ -284,23 +293,30 @@ imports:
- internal/remote_api
- internal/urlfetch
- urlfetch
- name: google.golang.org/genproto
version: de9f5e90fe9b278809363f08c2072d2f2a429de7
subpackages:
- googleapis/api/annotations
- name: google.golang.org/grpc
version: b7f1379d3cbbbeb2ca3405852012e237aa05459e
version: cdee119ee21e61eef7093a41ba148fa83585e143
subpackages:
- codes
- credentials
- grpclog
- internal
- keepalive
- metadata
- naming
- peer
- stats
- tap
- transport
- name: gopkg.in/inf.v0
version: 3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4
- name: gopkg.in/yaml.v2
version: a3f3340b5840cee44f372bddb5880fcbc419b46a
version: a5b47d31c556af34a302ce5d659e6fea44d90de0
- name: k8s.io/kubernetes
version: 00a1fb254bd8e5235575fba1398b958943e39078
version: 894ff23729bbc0055907dd3a496afb725396adda
subpackages:
- cmd/kubeadm/app/apis/kubeadm
- cmd/kubeadm/app/apis/kubeadm/install
@ -507,8 +523,6 @@ testImports:
subpackages:
- difflib
- name: github.com/stretchr/testify
version: e3a8ff8ce36581f87a15341206f205b1da467059
version: 69483b4bd14f5845b5a1e55bca19e954e827f1d0
subpackages:
- assert
- mock
- require

@ -15,13 +15,13 @@ import:
version: ~1.2.2
- package: github.com/technosophos/moniker
- package: github.com/golang/protobuf
version: df1d3ca07d2d07bba352d5b73c4313b4e2a6203e
version: 24f28ae800abfde9310e779f94be606b1a98a3fc
subpackages:
- proto
- ptypes/any
- ptypes/timestamp
- package: google.golang.org/grpc
version: 1.0.3
version: 1.2.0
- package: k8s.io/kubernetes
version: ~1.5.0
subpackages:
@ -69,3 +69,8 @@ import:
version: ~0.1.0
- package: github.com/naoina/go-stringutil
version: ~0.1.0
- package: google.golang.org/genproto
version: master
- package: github.com/grpc-ecosystem/grpc-gateway
repo: https://github.com/appscode/grpc-gateway.git
version: header-pass

@ -101,7 +101,7 @@ func init() { proto.RegisterFile("hapi/chart/chart.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 242 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4e, 0xc3, 0x30,
0x10, 0x86, 0x15, 0x4a, 0x0a, 0x1c, 0x2c, 0x58, 0x08, 0x4c, 0xa7, 0x8a, 0x09, 0x75, 0x70, 0x50,
0x11, 0x0f, 0x00, 0xcc, 0x2c, 0x16, 0x13, 0xdb, 0xb5, 0xb9, 0xa4, 0x91, 0x52, 0x3b, 0xaa, 0x5d,
0xa4, 0xbe, 0x3b, 0x03, 0xea, 0xd9, 0xa6, 0x09, 0xea, 0x12, 0x29, 0xf7, 0x7d, 0xff, 0xe5, 0xbf,

@ -24,6 +24,13 @@ func (m *Config) String() string { return proto.CompactTextString(m)
func (*Config) ProtoMessage() {}
func (*Config) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
func (m *Config) GetRaw() string {
if m != nil {
return m.Raw
}
return ""
}
func (m *Config) GetValues() map[string]*Value {
if m != nil {
return m.Values
@ -41,6 +48,13 @@ func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage() {}
func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
func (m *Value) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
func init() {
proto.RegisterType((*Config)(nil), "hapi.chart.Config")
proto.RegisterType((*Value)(nil), "hapi.chart.Value")
@ -50,7 +64,7 @@ func init() { proto.RegisterFile("hapi/chart/config.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 182 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0xc8,
0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28,
0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe8, 0x81, 0x25, 0x94, 0x16, 0x30, 0x72, 0xb1, 0x39,
0x83, 0x25, 0x85, 0x04, 0xb8, 0x98, 0x8b, 0x12, 0xcb, 0x25, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83,

@ -47,6 +47,20 @@ func (m *Maintainer) String() string { return proto.CompactTextString
func (*Maintainer) ProtoMessage() {}
func (*Maintainer) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *Maintainer) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Maintainer) GetEmail() string {
if m != nil {
return m.Email
}
return ""
}
// Metadata for a Chart file. This models the structure of a Chart.yaml file.
//
// Spec: https://k8s.io/helm/blob/master/docs/design/chart_format.md#the-chart-file
@ -86,6 +100,48 @@ func (m *Metadata) String() string { return proto.CompactTextString(m
func (*Metadata) ProtoMessage() {}
func (*Metadata) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
func (m *Metadata) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Metadata) GetHome() string {
if m != nil {
return m.Home
}
return ""
}
func (m *Metadata) GetSources() []string {
if m != nil {
return m.Sources
}
return nil
}
func (m *Metadata) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
func (m *Metadata) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Metadata) GetKeywords() []string {
if m != nil {
return m.Keywords
}
return nil
}
func (m *Metadata) GetMaintainers() []*Maintainer {
if m != nil {
return m.Maintainers
@ -93,6 +149,55 @@ func (m *Metadata) GetMaintainers() []*Maintainer {
return nil
}
func (m *Metadata) GetEngine() string {
if m != nil {
return m.Engine
}
return ""
}
func (m *Metadata) GetIcon() string {
if m != nil {
return m.Icon
}
return ""
}
func (m *Metadata) GetApiVersion() string {
if m != nil {
return m.ApiVersion
}
return ""
}
func (m *Metadata) GetCondition() string {
if m != nil {
return m.Condition
}
return ""
}
func (m *Metadata) GetTags() string {
if m != nil {
return m.Tags
}
return ""
}
func (m *Metadata) GetAppVersion() string {
if m != nil {
return m.AppVersion
}
return ""
}
func (m *Metadata) GetDeprecated() bool {
if m != nil {
return m.Deprecated
}
return false
}
func init() {
proto.RegisterType((*Maintainer)(nil), "hapi.chart.Maintainer")
proto.RegisterType((*Metadata)(nil), "hapi.chart.Metadata")
@ -103,7 +208,7 @@ func init() { proto.RegisterFile("hapi/chart/metadata.proto", fileDescriptor2) }
var fileDescriptor2 = []byte{
// 339 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0x4f, 0x4b, 0xeb, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4f, 0x4b, 0xeb, 0x40,
0x14, 0xc5, 0x5f, 0x5e, 0x9a, 0x7f, 0x37, 0xef, 0x3d, 0xca, 0xf0, 0x28, 0xa3, 0x88, 0x84, 0xae,
0xb2, 0x4a, 0x41, 0x41, 0x5c, 0x0b, 0xe2, 0x42, 0xdb, 0x4a, 0xf0, 0x0f, 0xb8, 0x1b, 0x93, 0x4b,
0x3b, 0x68, 0x66, 0xc2, 0xcc, 0xa8, 0xf8, 0xe5, 0xfc, 0x6c, 0x32, 0x93, 0xa4, 0xcd, 0xc2, 0xdd,

@ -29,6 +29,20 @@ func (m *Template) String() string { return proto.CompactTextString(m
func (*Template) ProtoMessage() {}
func (*Template) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *Template) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Template) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
proto.RegisterType((*Template)(nil), "hapi.chart.Template")
}
@ -37,7 +51,7 @@ func init() { proto.RegisterFile("hapi/chart/template.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 107 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xcc, 0x48, 0x2c, 0xc8,
0xd4, 0x4f, 0xce, 0x48, 0x2c, 0x2a, 0xd1, 0x2f, 0x49, 0xcd, 0x2d, 0xc8, 0x49, 0x2c, 0x49, 0xd5,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x02, 0x49, 0xe9, 0x81, 0xa5, 0x94, 0x8c, 0xb8, 0x38,
0x42, 0xa0, 0xb2, 0x42, 0x42, 0x5c, 0x2c, 0x79, 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a,

@ -107,6 +107,41 @@ func (m *Hook) String() string { return proto.CompactTextString(m) }
func (*Hook) ProtoMessage() {}
func (*Hook) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Hook) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Hook) GetKind() string {
if m != nil {
return m.Kind
}
return ""
}
func (m *Hook) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *Hook) GetManifest() string {
if m != nil {
return m.Manifest
}
return ""
}
func (m *Hook) GetEvents() []Hook_Event {
if m != nil {
return m.Events
}
return nil
}
func (m *Hook) GetLastRun() *google_protobuf.Timestamp {
if m != nil {
return m.LastRun
@ -123,7 +158,7 @@ func init() { proto.RegisterFile("hapi/release/hook.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 354 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xdd, 0x6e, 0xa2, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xdd, 0x6e, 0xa2, 0x40,
0x18, 0x86, 0x17, 0x41, 0xd0, 0xd1, 0x75, 0x67, 0x27, 0x9b, 0xec, 0xc4, 0x93, 0x35, 0x1e, 0x79,
0x34, 0x6c, 0x6c, 0x7a, 0x01, 0xa8, 0xd3, 0xd6, 0x48, 0xd0, 0x0c, 0x90, 0x26, 0x3d, 0x21, 0x98,
0x8e, 0x4a, 0x14, 0x86, 0x08, 0xf6, 0x72, 0x7a, 0x55, 0xbd, 0xa0, 0x66, 0x86, 0x9f, 0x34, 0xe9,

@ -58,6 +58,13 @@ func (m *Info) GetDeleted() *google_protobuf.Timestamp {
return nil
}
func (m *Info) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*Info)(nil), "hapi.release.Info")
}
@ -66,7 +73,7 @@ func init() { proto.RegisterFile("hapi/release/info.proto", fileDescriptor1) }
var fileDescriptor1 = []byte{
// 235 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x31, 0x4f, 0xc3, 0x30,
0x10, 0x85, 0x95, 0x52, 0x5a, 0xd5, 0x6d, 0x19, 0x2c, 0x24, 0x42, 0x16, 0x22, 0xa6, 0x0e, 0xc8,
0x91, 0x80, 0x1d, 0x81, 0xba, 0xb0, 0x06, 0x26, 0x16, 0xe4, 0xe2, 0x73, 0xb1, 0xe4, 0xe6, 0x2c,
0xfb, 0x3a, 0xf0, 0x2f, 0xf8, 0xc9, 0xa8, 0xb6, 0x83, 0xd2, 0xa9, 0xab, 0xbf, 0xf7, 0x3e, 0xbf,

@ -42,6 +42,13 @@ func (m *Release) String() string { return proto.CompactTextString(m)
func (*Release) ProtoMessage() {}
func (*Release) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
func (m *Release) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Release) GetInfo() *Info {
if m != nil {
return m.Info
@ -63,6 +70,13 @@ func (m *Release) GetConfig() *hapi_chart.Config {
return nil
}
func (m *Release) GetManifest() string {
if m != nil {
return m.Manifest
}
return ""
}
func (m *Release) GetHooks() []*Hook {
if m != nil {
return m.Hooks
@ -70,6 +84,20 @@ func (m *Release) GetHooks() []*Hook {
return nil
}
func (m *Release) GetVersion() int32 {
if m != nil {
return m.Version
}
return 0
}
func (m *Release) GetNamespace() string {
if m != nil {
return m.Namespace
}
return ""
}
func init() {
proto.RegisterType((*Release)(nil), "hapi.release.Release")
}
@ -78,7 +106,7 @@ func init() { proto.RegisterFile("hapi/release/release.proto", fileDescriptor2)
var fileDescriptor2 = []byte{
// 256 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xbf, 0x4e, 0xc3, 0x40,
0x0c, 0xc6, 0x95, 0x36, 0x7f, 0x1a, 0xc3, 0x82, 0x07, 0xb0, 0x22, 0x86, 0x88, 0x01, 0x22, 0x86,
0x54, 0x82, 0x37, 0x80, 0x05, 0xd6, 0x1b, 0xd9, 0x8e, 0xe8, 0x42, 0x4e, 0xa5, 0xe7, 0x28, 0x17,
0xf1, 0x2c, 0x3c, 0x2e, 0xba, 0x3f, 0x85, 0x94, 0x2e, 0x4e, 0xec, 0xdf, 0xa7, 0xcf, 0xdf, 0x19,

@ -69,6 +69,27 @@ func (m *Status) String() string { return proto.CompactTextString(m)
func (*Status) ProtoMessage() {}
func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
func (m *Status) GetCode() Status_Code {
if m != nil {
return m.Code
}
return Status_UNKNOWN
}
func (m *Status) GetResources() string {
if m != nil {
return m.Resources
}
return ""
}
func (m *Status) GetNotes() string {
if m != nil {
return m.Notes
}
return ""
}
func (m *Status) GetLastTestSuiteRun() *TestSuite {
if m != nil {
return m.LastTestSuiteRun
@ -85,7 +106,7 @@ func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) }
var fileDescriptor3 = []byte{
// 291 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30,
0x14, 0xc6, 0x57, 0xad, 0x3a, 0x8f, 0x22, 0x21, 0x1b, 0xac, 0xca, 0x06, 0xc5, 0xab, 0xde, 0xac,
0x05, 0xf7, 0x04, 0xdb, 0x12, 0x87, 0xac, 0x54, 0x69, 0x2b, 0xfb, 0x73, 0x53, 0xaa, 0x9e, 0x39,
0xa1, 0x34, 0xd2, 0x24, 0x17, 0x7b, 0x88, 0xbd, 0xf3, 0x68, 0x2b, 0x74, 0x5e, 0x7e, 0xf9, 0xfd,

@ -51,6 +51,27 @@ func (m *TestRun) String() string { return proto.CompactTextString(m)
func (*TestRun) ProtoMessage() {}
func (*TestRun) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
func (m *TestRun) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *TestRun) GetStatus() TestRun_Status {
if m != nil {
return m.Status
}
return TestRun_UNKNOWN
}
func (m *TestRun) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
func (m *TestRun) GetStartedAt() *google_protobuf.Timestamp {
if m != nil {
return m.StartedAt
@ -74,7 +95,7 @@ func init() { proto.RegisterFile("hapi/release/test_run.proto", fileDescriptor4)
var fileDescriptor4 = []byte{
// 265 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x41, 0x4b, 0xfb, 0x40,
0x14, 0xc4, 0xff, 0xc9, 0xbf, 0x26, 0x64, 0x53, 0x24, 0xec, 0x29, 0x54, 0xc1, 0xd0, 0x53, 0x4e,
0xbb, 0x50, 0xbd, 0x78, 0xf0, 0x10, 0x4b, 0x05, 0x51, 0x22, 0x6c, 0x1a, 0x04, 0x2f, 0x65, 0xab,
0xaf, 0x35, 0x90, 0x64, 0x43, 0xf6, 0xe5, 0x8b, 0xf8, 0x89, 0x65, 0x93, 0xad, 0x78, 0xf3, 0xf6,

@ -58,7 +58,7 @@ func init() { proto.RegisterFile("hapi/release/test_suite.proto", fileDescriptor
var fileDescriptor5 = []byte{
// 207 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0xc1, 0x4a, 0x86, 0x40,
0x14, 0x85, 0x31, 0x21, 0x71, 0x74, 0x35, 0x10, 0x88, 0x11, 0x49, 0x2b, 0x57, 0x33, 0x60, 0xab,
0x16, 0x2d, 0xec, 0x11, 0xcc, 0x55, 0x1b, 0x19, 0xeb, 0x66, 0xc2, 0xe8, 0x0c, 0x73, 0xef, 0xbc,
0x5a, 0xcf, 0x17, 0xea, 0x18, 0x41, 0x8b, 0x7f, 0xfd, 0x7d, 0xe7, 0x9c, 0x7b, 0xd9, 0xdd, 0x97,

@ -36,6 +36,7 @@ package services
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import hapi_chart3 "k8s.io/helm/pkg/proto/hapi/chart"
import hapi_chart "k8s.io/helm/pkg/proto/hapi/chart"
import hapi_release5 "k8s.io/helm/pkg/proto/hapi/release"
@ -138,6 +139,55 @@ func (m *ListReleasesRequest) String() string { return proto.CompactT
func (*ListReleasesRequest) ProtoMessage() {}
func (*ListReleasesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *ListReleasesRequest) GetLimit() int64 {
if m != nil {
return m.Limit
}
return 0
}
func (m *ListReleasesRequest) GetOffset() string {
if m != nil {
return m.Offset
}
return ""
}
func (m *ListReleasesRequest) GetSortBy() ListSort_SortBy {
if m != nil {
return m.SortBy
}
return ListSort_UNKNOWN
}
func (m *ListReleasesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
func (m *ListReleasesRequest) GetSortOrder() ListSort_SortOrder {
if m != nil {
return m.SortOrder
}
return ListSort_ASC
}
func (m *ListReleasesRequest) GetStatusCodes() []hapi_release3.Status_Code {
if m != nil {
return m.StatusCodes
}
return nil
}
func (m *ListReleasesRequest) GetNamespace() string {
if m != nil {
return m.Namespace
}
return ""
}
// ListSort defines sorting fields on a release list.
type ListSort struct {
}
@ -165,6 +215,27 @@ func (m *ListReleasesResponse) String() string { return proto.Compact
func (*ListReleasesResponse) ProtoMessage() {}
func (*ListReleasesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *ListReleasesResponse) GetCount() int64 {
if m != nil {
return m.Count
}
return 0
}
func (m *ListReleasesResponse) GetNext() string {
if m != nil {
return m.Next
}
return ""
}
func (m *ListReleasesResponse) GetTotal() int64 {
if m != nil {
return m.Total
}
return 0
}
func (m *ListReleasesResponse) GetReleases() []*hapi_release5.Release {
if m != nil {
return m.Releases
@ -185,6 +256,20 @@ func (m *GetReleaseStatusRequest) String() string { return proto.Comp
func (*GetReleaseStatusRequest) ProtoMessage() {}
func (*GetReleaseStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *GetReleaseStatusRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *GetReleaseStatusRequest) GetVersion() int32 {
if m != nil {
return m.Version
}
return 0
}
// GetReleaseStatusResponse is the response indicating the status of the named release.
type GetReleaseStatusResponse struct {
// Name is the name of the release.
@ -200,6 +285,13 @@ func (m *GetReleaseStatusResponse) String() string { return proto.Com
func (*GetReleaseStatusResponse) ProtoMessage() {}
func (*GetReleaseStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *GetReleaseStatusResponse) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *GetReleaseStatusResponse) GetInfo() *hapi_release4.Info {
if m != nil {
return m.Info
@ -207,6 +299,13 @@ func (m *GetReleaseStatusResponse) GetInfo() *hapi_release4.Info {
return nil
}
func (m *GetReleaseStatusResponse) GetNamespace() string {
if m != nil {
return m.Namespace
}
return ""
}
// GetReleaseContentRequest is a request to get the contents of a release.
type GetReleaseContentRequest struct {
// The name of the release
@ -220,6 +319,20 @@ func (m *GetReleaseContentRequest) String() string { return proto.Com
func (*GetReleaseContentRequest) ProtoMessage() {}
func (*GetReleaseContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *GetReleaseContentRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *GetReleaseContentRequest) GetVersion() int32 {
if m != nil {
return m.Version
}
return 0
}
// GetReleaseContentResponse is a response containing the contents of a release.
type GetReleaseContentResponse struct {
// The release content
@ -266,6 +379,13 @@ func (m *UpdateReleaseRequest) String() string { return proto.Compact
func (*UpdateReleaseRequest) ProtoMessage() {}
func (*UpdateReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *UpdateReleaseRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UpdateReleaseRequest) GetChart() *hapi_chart3.Chart {
if m != nil {
return m.Chart
@ -280,6 +400,48 @@ func (m *UpdateReleaseRequest) GetValues() *hapi_chart.Config {
return nil
}
func (m *UpdateReleaseRequest) GetDryRun() bool {
if m != nil {
return m.DryRun
}
return false
}
func (m *UpdateReleaseRequest) GetDisableHooks() bool {
if m != nil {
return m.DisableHooks
}
return false
}
func (m *UpdateReleaseRequest) GetRecreate() bool {
if m != nil {
return m.Recreate
}
return false
}
func (m *UpdateReleaseRequest) GetTimeout() int64 {
if m != nil {
return m.Timeout
}
return 0
}
func (m *UpdateReleaseRequest) GetResetValues() bool {
if m != nil {
return m.ResetValues
}
return false
}
func (m *UpdateReleaseRequest) GetWait() bool {
if m != nil {
return m.Wait
}
return false
}
// UpdateReleaseResponse is the response to an update request.
type UpdateReleaseResponse struct {
Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"`
@ -320,6 +482,55 @@ func (m *RollbackReleaseRequest) String() string { return proto.Compa
func (*RollbackReleaseRequest) ProtoMessage() {}
func (*RollbackReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
func (m *RollbackReleaseRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *RollbackReleaseRequest) GetDryRun() bool {
if m != nil {
return m.DryRun
}
return false
}
func (m *RollbackReleaseRequest) GetDisableHooks() bool {
if m != nil {
return m.DisableHooks
}
return false
}
func (m *RollbackReleaseRequest) GetVersion() int32 {
if m != nil {
return m.Version
}
return 0
}
func (m *RollbackReleaseRequest) GetRecreate() bool {
if m != nil {
return m.Recreate
}
return false
}
func (m *RollbackReleaseRequest) GetTimeout() int64 {
if m != nil {
return m.Timeout
}
return 0
}
func (m *RollbackReleaseRequest) GetWait() bool {
if m != nil {
return m.Wait
}
return false
}
// RollbackReleaseResponse is the response to an update request.
type RollbackReleaseResponse struct {
Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"`
@ -383,6 +594,55 @@ func (m *InstallReleaseRequest) GetValues() *hapi_chart.Config {
return nil
}
func (m *InstallReleaseRequest) GetDryRun() bool {
if m != nil {
return m.DryRun
}
return false
}
func (m *InstallReleaseRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *InstallReleaseRequest) GetDisableHooks() bool {
if m != nil {
return m.DisableHooks
}
return false
}
func (m *InstallReleaseRequest) GetNamespace() string {
if m != nil {
return m.Namespace
}
return ""
}
func (m *InstallReleaseRequest) GetReuseName() bool {
if m != nil {
return m.ReuseName
}
return false
}
func (m *InstallReleaseRequest) GetTimeout() int64 {
if m != nil {
return m.Timeout
}
return 0
}
func (m *InstallReleaseRequest) GetWait() bool {
if m != nil {
return m.Wait
}
return false
}
// InstallReleaseResponse is the response from a release installation.
type InstallReleaseResponse struct {
Release *hapi_release5.Release `protobuf:"bytes,1,opt,name=release" json:"release,omitempty"`
@ -417,6 +677,34 @@ func (m *UninstallReleaseRequest) String() string { return proto.Comp
func (*UninstallReleaseRequest) ProtoMessage() {}
func (*UninstallReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
func (m *UninstallReleaseRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UninstallReleaseRequest) GetDisableHooks() bool {
if m != nil {
return m.DisableHooks
}
return false
}
func (m *UninstallReleaseRequest) GetPurge() bool {
if m != nil {
return m.Purge
}
return false
}
func (m *UninstallReleaseRequest) GetTimeout() int64 {
if m != nil {
return m.Timeout
}
return 0
}
// UninstallReleaseResponse represents a successful response to an uninstall request.
type UninstallReleaseResponse struct {
// Release is the release that was marked deleted.
@ -437,6 +725,13 @@ func (m *UninstallReleaseResponse) GetRelease() *hapi_release5.Release {
return nil
}
func (m *UninstallReleaseResponse) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
// GetVersionRequest requests for version information.
type GetVersionRequest struct {
}
@ -475,6 +770,20 @@ func (m *GetHistoryRequest) String() string { return proto.CompactTex
func (*GetHistoryRequest) ProtoMessage() {}
func (*GetHistoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
func (m *GetHistoryRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *GetHistoryRequest) GetMax() int32 {
if m != nil {
return m.Max
}
return 0
}
// GetHistoryResponse is received in response to a GetHistory rpc.
type GetHistoryResponse struct {
Releases []*hapi_release5.Release `protobuf:"bytes,1,rep,name=releases" json:"releases,omitempty"`
@ -507,6 +816,27 @@ func (m *TestReleaseRequest) String() string { return proto.CompactTe
func (*TestReleaseRequest) ProtoMessage() {}
func (*TestReleaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
func (m *TestReleaseRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *TestReleaseRequest) GetTimeout() int64 {
if m != nil {
return m.Timeout
}
return 0
}
func (m *TestReleaseRequest) GetCleanup() bool {
if m != nil {
return m.Cleanup
}
return false
}
// TestReleaseResponse represents a message from executing a test
type TestReleaseResponse struct {
Msg string `protobuf:"bytes,1,opt,name=msg" json:"msg,omitempty"`
@ -517,6 +847,13 @@ func (m *TestReleaseResponse) String() string { return proto.CompactT
func (*TestReleaseResponse) ProtoMessage() {}
func (*TestReleaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
func (m *TestReleaseResponse) GetMsg() string {
if m != nil {
return m.Msg
}
return ""
}
func init() {
proto.RegisterType((*ListReleasesRequest)(nil), "hapi.services.tiller.ListReleasesRequest")
proto.RegisterType((*ListSort)(nil), "hapi.services.tiller.ListSort")
@ -549,7 +886,7 @@ 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.SupportPackageIsVersion3
const _ = grpc.SupportPackageIsVersion4
// Client API for ReleaseService service
@ -990,84 +1327,95 @@ var _ReleaseService_serviceDesc = grpc.ServiceDesc{
ServerStreams: true,
},
},
Metadata: fileDescriptor0,
Metadata: "hapi/services/tiller.proto",
}
func init() { proto.RegisterFile("hapi/services/tiller.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1162 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xe3, 0xc4,
0x17, 0xaf, 0xe3, 0x7c, 0x9e, 0x76, 0xfb, 0x4f, 0xa7, 0x5f, 0xae, 0xf5, 0x07, 0x15, 0x23, 0x68,
0x76, 0x61, 0x53, 0x08, 0x57, 0x48, 0x08, 0xa9, 0xdb, 0x8d, 0xda, 0x42, 0xe9, 0x4a, 0xce, 0x76,
0x91, 0x10, 0x22, 0x72, 0x93, 0x49, 0x6b, 0xd6, 0xf1, 0x04, 0xcf, 0xb8, 0x6c, 0x6f, 0xb9, 0xe3,
0x51, 0xe0, 0x29, 0x78, 0x02, 0x5e, 0x80, 0x97, 0x41, 0x9e, 0x0f, 0xd7, 0xe3, 0xda, 0xad, 0xe9,
0x4d, 0x3c, 0x33, 0xe7, 0xcc, 0xf9, 0xf8, 0x9d, 0x33, 0xbf, 0x99, 0x80, 0x7d, 0xe5, 0x2d, 0xfc,
0x7d, 0x8a, 0xa3, 0x6b, 0x7f, 0x82, 0xe9, 0x3e, 0xf3, 0x83, 0x00, 0x47, 0xfd, 0x45, 0x44, 0x18,
0x41, 0x1b, 0x89, 0xac, 0xaf, 0x64, 0x7d, 0x21, 0xb3, 0xb7, 0xf8, 0x8e, 0xc9, 0x95, 0x17, 0x31,
0xf1, 0x2b, 0xb4, 0xed, 0xed, 0xec, 0x3a, 0x09, 0x67, 0xfe, 0xa5, 0x14, 0x08, 0x17, 0x11, 0x0e,
0xb0, 0x47, 0xb1, 0xfa, 0x6a, 0x9b, 0x94, 0xcc, 0x0f, 0x67, 0x44, 0x0a, 0x76, 0x34, 0x01, 0x65,
0x1e, 0x8b, 0xa9, 0x66, 0xef, 0x1a, 0x47, 0xd4, 0x27, 0xa1, 0xfa, 0x0a, 0x99, 0xf3, 0x57, 0x0d,
0xd6, 0x4f, 0x7d, 0xca, 0x5c, 0xb1, 0x91, 0xba, 0xf8, 0x97, 0x18, 0x53, 0x86, 0x36, 0xa0, 0x11,
0xf8, 0x73, 0x9f, 0x59, 0xc6, 0xae, 0xd1, 0x33, 0x5d, 0x31, 0x41, 0x5b, 0xd0, 0x24, 0xb3, 0x19,
0xc5, 0xcc, 0xaa, 0xed, 0x1a, 0xbd, 0x8e, 0x2b, 0x67, 0xe8, 0x6b, 0x68, 0x51, 0x12, 0xb1, 0xf1,
0xc5, 0x8d, 0x65, 0xee, 0x1a, 0xbd, 0xd5, 0xc1, 0x47, 0xfd, 0x22, 0x28, 0xfa, 0x89, 0xa7, 0x11,
0x89, 0x58, 0x3f, 0xf9, 0x79, 0x71, 0xe3, 0x36, 0x29, 0xff, 0x26, 0x76, 0x67, 0x7e, 0xc0, 0x70,
0x64, 0xd5, 0x85, 0x5d, 0x31, 0x43, 0x47, 0x00, 0xdc, 0x2e, 0x89, 0xa6, 0x38, 0xb2, 0x1a, 0xdc,
0x74, 0xaf, 0x82, 0xe9, 0x57, 0x89, 0xbe, 0xdb, 0xa1, 0x6a, 0x88, 0xbe, 0x82, 0x15, 0x01, 0xc9,
0x78, 0x42, 0xa6, 0x98, 0x5a, 0xcd, 0x5d, 0xb3, 0xb7, 0x3a, 0xd8, 0x11, 0xa6, 0x14, 0xc2, 0x23,
0x01, 0xda, 0x21, 0x99, 0x62, 0x77, 0x59, 0xa8, 0x27, 0x63, 0x8a, 0xfe, 0x0f, 0x9d, 0xd0, 0x9b,
0x63, 0xba, 0xf0, 0x26, 0xd8, 0x6a, 0xf1, 0x08, 0x6f, 0x17, 0x9c, 0x9f, 0xa0, 0xad, 0x9c, 0x3b,
0x03, 0x68, 0x8a, 0xd4, 0xd0, 0x32, 0xb4, 0xce, 0xcf, 0xbe, 0x3d, 0x7b, 0xf5, 0xfd, 0x59, 0x77,
0x09, 0xb5, 0xa1, 0x7e, 0x76, 0xf0, 0xdd, 0xb0, 0x6b, 0xa0, 0x35, 0x78, 0x72, 0x7a, 0x30, 0x7a,
0x3d, 0x76, 0x87, 0xa7, 0xc3, 0x83, 0xd1, 0xf0, 0x65, 0xb7, 0xe6, 0xbc, 0x0f, 0x9d, 0x34, 0x66,
0xd4, 0x02, 0xf3, 0x60, 0x74, 0x28, 0xb6, 0xbc, 0x1c, 0x8e, 0x0e, 0xbb, 0x86, 0xf3, 0xbb, 0x01,
0x1b, 0x7a, 0x89, 0xe8, 0x82, 0x84, 0x14, 0x27, 0x35, 0x9a, 0x90, 0x38, 0x4c, 0x6b, 0xc4, 0x27,
0x08, 0x41, 0x3d, 0xc4, 0xef, 0x54, 0x85, 0xf8, 0x38, 0xd1, 0x64, 0x84, 0x79, 0x01, 0xaf, 0x8e,
0xe9, 0x8a, 0x09, 0xfa, 0x1c, 0xda, 0x32, 0x75, 0x6a, 0xd5, 0x77, 0xcd, 0xde, 0xf2, 0x60, 0x53,
0x07, 0x44, 0x7a, 0x74, 0x53, 0x35, 0xe7, 0x08, 0xb6, 0x8f, 0xb0, 0x8a, 0x44, 0xe0, 0xa5, 0x3a,
0x26, 0xf1, 0xeb, 0xcd, 0x31, 0x0f, 0x26, 0xf1, 0xeb, 0xcd, 0x31, 0xb2, 0xa0, 0x25, 0xdb, 0x8d,
0x87, 0xd3, 0x70, 0xd5, 0xd4, 0x61, 0x60, 0xdd, 0x35, 0x24, 0xf3, 0x2a, 0xb2, 0xf4, 0x31, 0xd4,
0x93, 0x66, 0xe7, 0x66, 0x96, 0x07, 0x48, 0x8f, 0xf3, 0x24, 0x9c, 0x11, 0x97, 0xcb, 0xf5, 0x52,
0x99, 0xf9, 0x52, 0x1d, 0x67, 0xbd, 0x1e, 0x92, 0x90, 0xe1, 0x90, 0x3d, 0x2e, 0xfe, 0x53, 0xd8,
0x29, 0xb0, 0x24, 0x13, 0xd8, 0x87, 0x96, 0x0c, 0x8d, 0x5b, 0x2b, 0xc5, 0x55, 0x69, 0x39, 0x7f,
0xd6, 0x60, 0xe3, 0x7c, 0x31, 0xf5, 0x18, 0x56, 0xa2, 0x7b, 0x82, 0xda, 0x83, 0x06, 0x27, 0x0d,
0x89, 0xc5, 0x9a, 0xb0, 0x2d, 0x98, 0xe5, 0x30, 0xf9, 0x75, 0x85, 0x1c, 0x3d, 0x83, 0xe6, 0xb5,
0x17, 0xc4, 0x98, 0x72, 0x20, 0x52, 0xd4, 0xa4, 0x26, 0x67, 0x1c, 0x57, 0x6a, 0xa0, 0x6d, 0x68,
0x4d, 0xa3, 0x9b, 0x71, 0x14, 0x87, 0xfc, 0x08, 0xb6, 0xdd, 0xe6, 0x34, 0xba, 0x71, 0xe3, 0x10,
0x7d, 0x08, 0x4f, 0xa6, 0x3e, 0xf5, 0x2e, 0x02, 0x3c, 0xbe, 0x22, 0xe4, 0x2d, 0xe5, 0xa7, 0xb0,
0xed, 0xae, 0xc8, 0xc5, 0xe3, 0x64, 0x0d, 0xd9, 0x49, 0x27, 0x4d, 0x22, 0xec, 0x31, 0x6c, 0x35,
0xb9, 0x3c, 0x9d, 0x27, 0x18, 0x32, 0x7f, 0x8e, 0x49, 0xcc, 0xf8, 0xd1, 0x31, 0x5d, 0x35, 0x45,
0x1f, 0xc0, 0x4a, 0x84, 0x29, 0x66, 0x63, 0x19, 0x65, 0x9b, 0xef, 0x5c, 0xe6, 0x6b, 0x6f, 0x44,
0x58, 0x08, 0xea, 0xbf, 0x7a, 0x3e, 0xb3, 0x3a, 0x5c, 0xc4, 0xc7, 0xce, 0x31, 0x6c, 0xe6, 0xb0,
0x7a, 0x2c, 0xec, 0x7f, 0x1b, 0xb0, 0xe5, 0x92, 0x20, 0xb8, 0xf0, 0x26, 0x6f, 0x2b, 0x00, 0x9f,
0xc1, 0xa8, 0x76, 0x3f, 0x46, 0x66, 0x01, 0x46, 0x99, 0x5e, 0xaa, 0x6b, 0xbd, 0xa4, 0xa1, 0xd7,
0x28, 0x47, 0xaf, 0xa9, 0xa3, 0xa7, 0xa0, 0x69, 0x65, 0xa0, 0xf9, 0x06, 0xb6, 0xef, 0xe4, 0xf3,
0x58, 0x70, 0xfe, 0xa8, 0xc1, 0xe6, 0x49, 0x48, 0x99, 0x17, 0x04, 0x39, 0x6c, 0xd2, 0x06, 0x34,
0x2a, 0x37, 0x60, 0xed, 0xbf, 0x34, 0xa0, 0xa9, 0x81, 0xab, 0x2a, 0x51, 0xcf, 0x54, 0xa2, 0x52,
0x53, 0x6a, 0x54, 0xd0, 0xcc, 0x51, 0x01, 0x7a, 0x0f, 0x20, 0xc2, 0x31, 0xc5, 0x63, 0x6e, 0x5c,
0x80, 0xd8, 0xe1, 0x2b, 0x67, 0xf2, 0xe4, 0x2b, 0xdc, 0xdb, 0xc5, 0xb8, 0x67, 0x5b, 0xf2, 0x04,
0xb6, 0xf2, 0x50, 0x3d, 0x16, 0xf6, 0xdf, 0x0c, 0xd8, 0x3e, 0x0f, 0xfd, 0x42, 0xe0, 0x8b, 0x9a,
0xf2, 0x0e, 0x14, 0xb5, 0x02, 0x28, 0x36, 0xa0, 0xb1, 0x88, 0xa3, 0x4b, 0x2c, 0xa1, 0x15, 0x93,
0x6c, 0x8e, 0x75, 0x2d, 0x47, 0x67, 0x0c, 0xd6, 0xdd, 0x18, 0x1e, 0x99, 0x51, 0x12, 0x75, 0x4a,
0xdd, 0x1d, 0x41, 0xd3, 0xce, 0x3a, 0xac, 0x1d, 0x61, 0xf6, 0x46, 0x1c, 0x00, 0x99, 0x9e, 0x33,
0x04, 0x94, 0x5d, 0xbc, 0xf5, 0x27, 0x97, 0x74, 0x7f, 0xea, 0x1d, 0xa3, 0xf4, 0x95, 0x96, 0xf3,
0x25, 0xb7, 0x7d, 0xec, 0x53, 0x46, 0xa2, 0x9b, 0xfb, 0xa0, 0xeb, 0x82, 0x39, 0xf7, 0xde, 0x49,
0x66, 0x4f, 0x86, 0xce, 0x11, 0x8f, 0x20, 0xdd, 0x2a, 0x23, 0xc8, 0xde, 0x93, 0x46, 0xb5, 0x7b,
0xf2, 0x47, 0x40, 0xaf, 0x71, 0x7a, 0x65, 0x3f, 0x70, 0xc5, 0xa8, 0x22, 0xd4, 0xf4, 0x46, 0xb3,
0xa0, 0x35, 0x09, 0xb0, 0x17, 0xc6, 0x0b, 0x59, 0x36, 0x35, 0x75, 0xf6, 0x60, 0x5d, 0xb3, 0x2e,
0xe3, 0x4c, 0xf2, 0xa1, 0x97, 0xd2, 0x7a, 0x32, 0x1c, 0xfc, 0xd3, 0x86, 0x55, 0x75, 0xc7, 0x8a,
0xf7, 0x12, 0xf2, 0x61, 0x25, 0xfb, 0x98, 0x40, 0x4f, 0xcb, 0x9f, 0x53, 0xb9, 0x37, 0xa1, 0xfd,
0xac, 0x8a, 0xaa, 0x88, 0xc5, 0x59, 0xfa, 0xcc, 0x40, 0x14, 0xba, 0xf9, 0x3b, 0x1e, 0x3d, 0x2f,
0xb6, 0x51, 0xf2, 0xa8, 0xb0, 0xfb, 0x55, 0xd5, 0x95, 0x5b, 0x74, 0xcd, 0xab, 0xaf, 0x5f, 0xcc,
0xe8, 0x41, 0x33, 0xfa, 0x5b, 0xc0, 0xde, 0xaf, 0xac, 0x9f, 0xfa, 0xfd, 0x19, 0x9e, 0x68, 0xb7,
0x12, 0x2a, 0x41, 0xab, 0xe8, 0x9a, 0xb7, 0x3f, 0xa9, 0xa4, 0x9b, 0xfa, 0x9a, 0xc3, 0xaa, 0x4e,
0x37, 0xa8, 0xc4, 0x40, 0x21, 0x7f, 0xdb, 0x9f, 0x56, 0x53, 0x4e, 0xdd, 0x51, 0xe8, 0xe6, 0xd9,
0xa0, 0xac, 0x8e, 0x25, 0xcc, 0x55, 0x56, 0xc7, 0x32, 0x92, 0x71, 0x96, 0x90, 0x07, 0x70, 0x4b,
0x06, 0x68, 0xaf, 0xb4, 0x20, 0x3a, 0x87, 0xd8, 0xbd, 0x87, 0x15, 0x53, 0x17, 0x0b, 0xf8, 0x5f,
0xee, 0xb6, 0x44, 0x25, 0xd0, 0x14, 0x3f, 0x12, 0xec, 0xe7, 0x15, 0xb5, 0x73, 0x49, 0x49, 0x7e,
0xb9, 0x27, 0x29, 0x9d, 0xbc, 0xee, 0x49, 0x2a, 0x47, 0x55, 0xce, 0x12, 0xf2, 0x61, 0xd5, 0x8d,
0x43, 0xe9, 0x3a, 0x61, 0x09, 0x54, 0xb2, 0xfb, 0x2e, 0x3f, 0xd9, 0x4f, 0x2b, 0x68, 0xde, 0x9e,
0xef, 0x17, 0xf0, 0x43, 0x5b, 0xa9, 0x5e, 0x34, 0xf9, 0xdf, 0xc9, 0x2f, 0xfe, 0x0d, 0x00, 0x00,
0xff, 0xff, 0xf9, 0x32, 0x44, 0xf7, 0x1f, 0x0f, 0x00, 0x00,
// 1333 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0x67, 0x6d, 0xc7, 0x7f, 0x5e, 0xd2, 0xe0, 0x4e, 0xd3, 0x64, 0xb3, 0x2a, 0xd4, 0x5d, 0xfe,
0xc4, 0x35, 0xad, 0xdd, 0x9a, 0x03, 0x6a, 0xa9, 0x90, 0xd2, 0xd4, 0x4a, 0x0a, 0x21, 0x95, 0xd6,
0x6d, 0x91, 0x10, 0xc2, 0xda, 0xd8, 0xe3, 0x74, 0xe9, 0x7a, 0xc7, 0xec, 0x8c, 0x43, 0xa3, 0xaa,
0x12, 0xea, 0x89, 0x9e, 0x41, 0x42, 0xe2, 0xc4, 0x15, 0x8e, 0x88, 0x03, 0x47, 0xc4, 0x07, 0xe0,
0xc2, 0x57, 0xe0, 0x83, 0xa0, 0x9d, 0x3f, 0xee, 0x8e, 0xb3, 0xeb, 0x6c, 0xc3, 0xc5, 0x3b, 0x33,
0xef, 0xcd, 0x7b, 0xbf, 0xf9, 0xbd, 0x37, 0x6f, 0x5e, 0x02, 0xd6, 0x23, 0x77, 0xec, 0xb5, 0x28,
0x0e, 0x0f, 0xbd, 0x3e, 0xa6, 0x2d, 0xe6, 0xf9, 0x3e, 0x0e, 0x9b, 0xe3, 0x90, 0x30, 0x82, 0x56,
0x22, 0x59, 0x53, 0xc9, 0x9a, 0x42, 0x66, 0x5d, 0x38, 0x20, 0xe4, 0xc0, 0xc7, 0xad, 0x68, 0x9f,
0x1b, 0x04, 0x84, 0xb9, 0xcc, 0x23, 0x01, 0x15, 0x7b, 0xac, 0x55, 0x6e, 0xaf, 0xff, 0xc8, 0x0d,
0x99, 0xf8, 0x95, 0xeb, 0x6b, 0xf1, 0x75, 0x12, 0x0c, 0xbd, 0x03, 0x29, 0x10, 0x00, 0x42, 0xec,
0x63, 0x97, 0x62, 0xf5, 0xd5, 0x36, 0x29, 0x99, 0x17, 0x0c, 0x89, 0x14, 0xac, 0x6b, 0x02, 0xca,
0x5c, 0x36, 0xa1, 0x9a, 0xbd, 0x43, 0x1c, 0x52, 0x8f, 0x04, 0xea, 0x2b, 0x64, 0xf6, 0x9f, 0x39,
0x38, 0xb7, 0xeb, 0x51, 0xe6, 0x88, 0x8d, 0xd4, 0xc1, 0x5f, 0x4f, 0x30, 0x65, 0x68, 0x05, 0x16,
0x7c, 0x6f, 0xe4, 0x31, 0xd3, 0xa8, 0x19, 0xf5, 0xbc, 0x23, 0x26, 0x68, 0x15, 0x8a, 0x64, 0x38,
0xa4, 0x98, 0x99, 0xb9, 0x9a, 0x51, 0xaf, 0x38, 0x72, 0x86, 0x3e, 0x82, 0x12, 0x25, 0x21, 0xeb,
0xed, 0x1f, 0x99, 0xf9, 0x9a, 0x51, 0x5f, 0x6e, 0xbf, 0xd3, 0x4c, 0x22, 0xaa, 0x19, 0x79, 0xea,
0x92, 0x90, 0x35, 0xa3, 0x9f, 0xdb, 0x47, 0x4e, 0x91, 0xf2, 0x6f, 0x64, 0x77, 0xe8, 0xf9, 0x0c,
0x87, 0x66, 0x41, 0xd8, 0x15, 0x33, 0xb4, 0x0d, 0xc0, 0xed, 0x92, 0x70, 0x80, 0x43, 0x73, 0x81,
0x9b, 0xae, 0x67, 0x30, 0x7d, 0x2f, 0xd2, 0x77, 0x2a, 0x54, 0x0d, 0xd1, 0x2d, 0x58, 0x12, 0x94,
0xf4, 0xfa, 0x64, 0x80, 0xa9, 0x59, 0xac, 0xe5, 0xeb, 0xcb, 0xed, 0x75, 0x61, 0x4a, 0x31, 0xdc,
0x15, 0xa4, 0x6d, 0x91, 0x01, 0x76, 0x16, 0x85, 0x7a, 0x34, 0xa6, 0xe8, 0x02, 0x54, 0x02, 0x77,
0x84, 0xe9, 0xd8, 0xed, 0x63, 0xb3, 0xc4, 0x11, 0xbe, 0x5c, 0xb0, 0xbf, 0x84, 0xb2, 0x72, 0x6e,
0xb7, 0xa1, 0x28, 0x8e, 0x86, 0x16, 0xa1, 0xf4, 0x60, 0xef, 0x93, 0xbd, 0x7b, 0x9f, 0xed, 0x55,
0x5f, 0x43, 0x65, 0x28, 0xec, 0x6d, 0x7e, 0xda, 0xa9, 0x1a, 0xe8, 0x2c, 0x9c, 0xd9, 0xdd, 0xec,
0xde, 0xef, 0x39, 0x9d, 0xdd, 0xce, 0x66, 0xb7, 0x73, 0xa7, 0x9a, 0xb3, 0xdf, 0x84, 0xca, 0x14,
0x33, 0x2a, 0x41, 0x7e, 0xb3, 0xbb, 0x25, 0xb6, 0xdc, 0xe9, 0x74, 0xb7, 0xaa, 0x86, 0xfd, 0xc2,
0x80, 0x15, 0x3d, 0x44, 0x74, 0x4c, 0x02, 0x8a, 0xa3, 0x18, 0xf5, 0xc9, 0x24, 0x98, 0xc6, 0x88,
0x4f, 0x10, 0x82, 0x42, 0x80, 0x9f, 0xa8, 0x08, 0xf1, 0x71, 0xa4, 0xc9, 0x08, 0x73, 0x7d, 0x1e,
0x9d, 0xbc, 0x23, 0x26, 0xe8, 0x3a, 0x94, 0xe5, 0xd1, 0xa9, 0x59, 0xa8, 0xe5, 0xeb, 0x8b, 0xed,
0xf3, 0x3a, 0x21, 0xd2, 0xa3, 0x33, 0x55, 0xb3, 0xb7, 0x61, 0x6d, 0x1b, 0x2b, 0x24, 0x82, 0x2f,
0x95, 0x31, 0x91, 0x5f, 0x77, 0x84, 0x39, 0x98, 0xc8, 0xaf, 0x3b, 0xc2, 0xc8, 0x84, 0x92, 0x4c,
0x37, 0x0e, 0x67, 0xc1, 0x51, 0x53, 0x9b, 0x81, 0x79, 0xdc, 0x90, 0x3c, 0x57, 0x92, 0xa5, 0x77,
0xa1, 0x10, 0x25, 0x3b, 0x37, 0xb3, 0xd8, 0x46, 0x3a, 0xce, 0xbb, 0xc1, 0x90, 0x38, 0x5c, 0xae,
0x87, 0x2a, 0x3f, 0x1b, 0xaa, 0x9d, 0xb8, 0xd7, 0x2d, 0x12, 0x30, 0x1c, 0xb0, 0xd3, 0xe1, 0xdf,
0x85, 0xf5, 0x04, 0x4b, 0xf2, 0x00, 0x2d, 0x28, 0x49, 0x68, 0xdc, 0x5a, 0x2a, 0xaf, 0x4a, 0xcb,
0xfe, 0x35, 0x07, 0x2b, 0x0f, 0xc6, 0x03, 0x97, 0x61, 0x25, 0x9a, 0x03, 0x6a, 0x03, 0x16, 0x78,
0xd1, 0x90, 0x5c, 0x9c, 0x15, 0xb6, 0x45, 0x65, 0xd9, 0x8a, 0x7e, 0x1d, 0x21, 0x47, 0x0d, 0x28,
0x1e, 0xba, 0xfe, 0x04, 0x53, 0x4e, 0xc4, 0x94, 0x35, 0xa9, 0xc9, 0x2b, 0x8e, 0x23, 0x35, 0xd0,
0x1a, 0x94, 0x06, 0xe1, 0x51, 0x2f, 0x9c, 0x04, 0xfc, 0x0a, 0x96, 0x9d, 0xe2, 0x20, 0x3c, 0x72,
0x26, 0x01, 0x7a, 0x0b, 0xce, 0x0c, 0x3c, 0xea, 0xee, 0xfb, 0xb8, 0xf7, 0x88, 0x90, 0xc7, 0x94,
0xdf, 0xc2, 0xb2, 0xb3, 0x24, 0x17, 0x77, 0xa2, 0x35, 0x64, 0x45, 0x99, 0xd4, 0x0f, 0xb1, 0xcb,
0xb0, 0x59, 0xe4, 0xf2, 0xe9, 0x3c, 0xe2, 0x90, 0x79, 0x23, 0x4c, 0x26, 0x8c, 0x5f, 0x9d, 0xbc,
0xa3, 0xa6, 0xe8, 0x12, 0x2c, 0x85, 0x98, 0x62, 0xd6, 0x93, 0x28, 0xcb, 0x7c, 0xe7, 0x22, 0x5f,
0x7b, 0x28, 0x60, 0x21, 0x28, 0x7c, 0xe3, 0x7a, 0xcc, 0xac, 0x70, 0x11, 0x1f, 0xdb, 0x3b, 0x70,
0x7e, 0x86, 0xab, 0xd3, 0xd2, 0xfe, 0xb7, 0x01, 0xab, 0x0e, 0xf1, 0xfd, 0x7d, 0xb7, 0xff, 0x38,
0x03, 0xf1, 0x31, 0x8e, 0x72, 0xf3, 0x39, 0xca, 0x27, 0x70, 0x14, 0xcb, 0xa5, 0x82, 0x96, 0x4b,
0x1a, 0x7b, 0x0b, 0xe9, 0xec, 0x15, 0x75, 0xf6, 0x14, 0x35, 0xa5, 0x18, 0x35, 0x1f, 0xc3, 0xda,
0xb1, 0xf3, 0x9c, 0x96, 0x9c, 0x5f, 0x72, 0x70, 0xfe, 0x6e, 0x40, 0x99, 0xeb, 0xfb, 0x33, 0xdc,
0x4c, 0x13, 0xd0, 0xc8, 0x9c, 0x80, 0xb9, 0x57, 0x49, 0xc0, 0xbc, 0x46, 0xae, 0x8a, 0x44, 0x21,
0x16, 0x89, 0x4c, 0x49, 0xa9, 0x95, 0x82, 0xe2, 0x4c, 0x29, 0x40, 0x6f, 0x00, 0x84, 0x78, 0x42,
0x71, 0x8f, 0x1b, 0x17, 0x24, 0x56, 0xf8, 0xca, 0x9e, 0xbc, 0xf9, 0x8a, 0xf7, 0x72, 0x32, 0xef,
0xf1, 0x94, 0xbc, 0x0b, 0xab, 0xb3, 0x54, 0x9d, 0x96, 0xf6, 0xe7, 0x06, 0xac, 0x3d, 0x08, 0xbc,
0x44, 0xe2, 0x93, 0x92, 0xf2, 0x18, 0x15, 0xb9, 0x04, 0x2a, 0x56, 0x60, 0x61, 0x3c, 0x09, 0x0f,
0xb0, 0xa4, 0x56, 0x4c, 0xe2, 0x67, 0x2c, 0x68, 0x67, 0xb4, 0x7b, 0x60, 0x1e, 0xc7, 0x70, 0xca,
0x13, 0x45, 0xa8, 0xa7, 0xa5, 0xbb, 0x22, 0xca, 0xb4, 0x7d, 0x0e, 0xce, 0x6e, 0x63, 0xf6, 0x50,
0x5c, 0x00, 0x79, 0x3c, 0xbb, 0x03, 0x28, 0xbe, 0xf8, 0xd2, 0x9f, 0x5c, 0xd2, 0xfd, 0xa9, 0x3e,
0x46, 0xe9, 0x2b, 0x2d, 0xfb, 0x06, 0xb7, 0xbd, 0xe3, 0x51, 0x46, 0xc2, 0xa3, 0x79, 0xd4, 0x55,
0x21, 0x3f, 0x72, 0x9f, 0xc8, 0xca, 0x1e, 0x0d, 0xed, 0x6d, 0x8e, 0x60, 0xba, 0x55, 0x22, 0x88,
0xbf, 0x93, 0x46, 0xb6, 0x77, 0xf2, 0x0b, 0x40, 0xf7, 0xf1, 0xf4, 0xc9, 0x3e, 0xe1, 0x89, 0x51,
0x41, 0xc8, 0xe9, 0x89, 0x66, 0x42, 0xa9, 0xef, 0x63, 0x37, 0x98, 0x8c, 0x65, 0xd8, 0xd4, 0xd4,
0xde, 0x80, 0x73, 0x9a, 0x75, 0x89, 0x33, 0x3a, 0x0f, 0x3d, 0x90, 0xd6, 0xa3, 0x61, 0xfb, 0xaf,
0x25, 0x58, 0x56, 0x6f, 0xac, 0xe8, 0x97, 0xd0, 0x0b, 0x03, 0x96, 0xe2, 0xdd, 0x04, 0xba, 0x9c,
0xde, 0x4f, 0xcd, 0x34, 0x85, 0x56, 0x23, 0x8b, 0xaa, 0x00, 0x63, 0xd7, 0x9e, 0xff, 0xf3, 0xef,
0xf7, 0x39, 0x0b, 0x99, 0xb2, 0x81, 0x6e, 0x1d, 0xb6, 0x55, 0x77, 0x4a, 0x5b, 0x5f, 0x51, 0x12,
0x5c, 0x33, 0xd0, 0xef, 0x06, 0x54, 0x67, 0xbb, 0x00, 0x74, 0x35, 0xd9, 0x49, 0x4a, 0xdb, 0x61,
0x35, 0xb3, 0xaa, 0x4b, 0x5c, 0x9b, 0x1c, 0xd7, 0x87, 0xe8, 0x46, 0x12, 0xae, 0xa7, 0x51, 0x48,
0x9e, 0xa9, 0x16, 0x99, 0xb6, 0x9e, 0xca, 0xd1, 0x33, 0xd9, 0x50, 0x73, 0xe0, 0xe8, 0x0f, 0x83,
0x67, 0x98, 0xfe, 0xf8, 0xa3, 0x13, 0x81, 0xe8, 0xfd, 0x86, 0xd5, 0xca, 0xac, 0x2f, 0x91, 0xdf,
0xe6, 0xc8, 0x6f, 0xa1, 0x9b, 0xaf, 0x86, 0xbc, 0x2f, 0xcc, 0x08, 0xe8, 0x3f, 0x18, 0x70, 0x46,
0x7b, 0x3c, 0x51, 0x4a, 0x4c, 0x93, 0xba, 0x11, 0xeb, 0xbd, 0x4c, 0xba, 0x12, 0x6e, 0x83, 0xc3,
0x7d, 0xdb, 0xba, 0x38, 0x07, 0x6e, 0x84, 0xe9, 0xa6, 0xd1, 0x40, 0x3f, 0x1a, 0xb0, 0xac, 0x17,
0x50, 0x94, 0xe2, 0x2b, 0xf1, 0x45, 0xb2, 0xae, 0x64, 0x53, 0xd6, 0x91, 0xd9, 0x59, 0x90, 0xfd,
0x64, 0x40, 0x75, 0xb6, 0x14, 0xa6, 0xa5, 0x68, 0x4a, 0xd9, 0x4e, 0x4b, 0xd1, 0xb4, 0x0a, 0x6b,
0x6f, 0x70, 0x7c, 0x97, 0x1a, 0x27, 0xe1, 0x43, 0xdf, 0x1a, 0x00, 0x2f, 0x2b, 0x26, 0xda, 0x48,
0xcd, 0x28, 0xbd, 0xd0, 0x5a, 0xf5, 0x93, 0x15, 0x25, 0x94, 0x8b, 0x1c, 0xca, 0x3a, 0x5a, 0x8b,
0x41, 0x51, 0x7f, 0x48, 0x72, 0x08, 0xbf, 0x19, 0xf0, 0xfa, 0x4c, 0xcb, 0x81, 0x52, 0xa2, 0x91,
0xdc, 0x69, 0x59, 0x57, 0x33, 0x6a, 0xeb, 0xb7, 0xa0, 0xf1, 0x7f, 0x6e, 0xc1, 0x77, 0x82, 0x37,
0x59, 0xe7, 0xe7, 0xf0, 0xa6, 0x3f, 0x22, 0x73, 0x78, 0x9b, 0x79, 0x32, 0x54, 0x08, 0xd1, 0x89,
0x21, 0xfc, 0xd9, 0x80, 0x65, 0x67, 0x12, 0xc8, 0x53, 0x46, 0x55, 0x1d, 0xa5, 0x78, 0x39, 0xfe,
0x9e, 0x58, 0x97, 0x33, 0x68, 0x4a, 0x40, 0x1f, 0x70, 0x40, 0xd7, 0xed, 0x2b, 0x73, 0x00, 0xb9,
0x7d, 0xfe, 0x6f, 0x8b, 0x16, 0xc3, 0x94, 0xa9, 0x0b, 0x70, 0xcd, 0xb8, 0x0d, 0x9f, 0x97, 0x95,
0x87, 0xfd, 0x22, 0xff, 0xaf, 0xc1, 0xfb, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x17, 0xc3,
0x8e, 0x24, 0x11, 0x00, 0x00,
}

@ -0,0 +1,712 @@
// Code generated by protoc-gen-grpc-gateway
// source: hapi/services/tiller.proto
// DO NOT EDIT!
/*
Package services is a reverse proxy.
It translates gRPC into RESTful JSON APIs.
*/
package services
import (
"io"
"net/http"
"github.com/golang/protobuf/proto"
"github.com/grpc-ecosystem/grpc-gateway/runtime"
"github.com/grpc-ecosystem/grpc-gateway/utilities"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
)
var _ codes.Code
var _ io.Reader
var _ = runtime.String
var _ = utilities.NewDoubleArray
var (
filter_ReleaseService_ListReleases_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_ReleaseService_ListReleases_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (ReleaseService_ListReleasesClient, runtime.ServerMetadata, error) {
var protoReq ListReleasesRequest
var metadata runtime.ServerMetadata
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_ReleaseService_ListReleases_0); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
stream, err := client.ListReleases(ctx, &protoReq)
if err != nil {
return nil, metadata, err
}
header, err := stream.Header()
if err != nil {
return nil, metadata, err
}
metadata.HeaderMD = header
return stream, metadata, nil
}
func request_ReleaseService_GetReleaseStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetReleaseStatusRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
val, ok = pathParams["version"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "version")
}
protoReq.Version, err = runtime.Int32(val)
if err != nil {
return nil, metadata, err
}
msg, err := client.GetReleaseStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_ReleaseService_GetReleaseContent_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetReleaseContentRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
val, ok = pathParams["version"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "version")
}
protoReq.Version, err = runtime.Int32(val)
if err != nil {
return nil, metadata, err
}
msg, err := client.GetReleaseContent(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_ReleaseService_UpdateRelease_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq UpdateReleaseRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
msg, err := client.UpdateRelease(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_ReleaseService_InstallRelease_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq InstallReleaseRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
msg, err := client.InstallRelease(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
var (
filter_ReleaseService_UninstallRelease_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
func request_ReleaseService_UninstallRelease_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq UninstallReleaseRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_ReleaseService_UninstallRelease_0); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.UninstallRelease(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_ReleaseService_GetVersion_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetVersionRequest
var metadata runtime.ServerMetadata
msg, err := client.GetVersion(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
var (
filter_ReleaseService_RollbackRelease_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0, "version": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
)
func request_ReleaseService_RollbackRelease_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq RollbackReleaseRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
val, ok = pathParams["version"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "version")
}
protoReq.Version, err = runtime.Int32(val)
if err != nil {
return nil, metadata, err
}
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_ReleaseService_RollbackRelease_0); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.RollbackRelease(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
var (
filter_ReleaseService_GetHistory_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
func request_ReleaseService_GetHistory_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetHistoryRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_ReleaseService_GetHistory_0); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.GetHistory(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_ReleaseService_RunReleaseTest_0(ctx context.Context, marshaler runtime.Marshaler, client ReleaseServiceClient, req *http.Request, pathParams map[string]string) (ReleaseService_RunReleaseTestClient, runtime.ServerMetadata, error) {
var protoReq TestReleaseRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
}
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["name"]
if !ok {
return nil, metadata, grpc.Errorf(codes.InvalidArgument, "missing parameter %s", "name")
}
protoReq.Name, err = runtime.String(val)
if err != nil {
return nil, metadata, err
}
stream, err := client.RunReleaseTest(ctx, &protoReq)
if err != nil {
return nil, metadata, err
}
header, err := stream.Header()
if err != nil {
return nil, metadata, err
}
metadata.HeaderMD = header
return stream, metadata, nil
}
// RegisterReleaseServiceHandlerFromEndpoint is same as RegisterReleaseServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterReleaseServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
conn, err := grpc.Dial(endpoint, opts...)
if err != nil {
return err
}
defer func() {
if err != nil {
if cerr := conn.Close(); cerr != nil {
grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
}
return
}
go func() {
<-ctx.Done()
if cerr := conn.Close(); cerr != nil {
grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
}
}()
}()
return RegisterReleaseServiceHandler(ctx, mux, conn)
}
// RegisterReleaseServiceHandler registers the http handlers for service ReleaseService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterReleaseServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
client := NewReleaseServiceClient(conn)
mux.Handle("GET", pattern_ReleaseService_ListReleases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_ListReleases_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_ListReleases_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_ReleaseService_GetReleaseStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_GetReleaseStatus_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_GetReleaseStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_ReleaseService_GetReleaseContent_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_GetReleaseContent_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_GetReleaseContent_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("PUT", pattern_ReleaseService_UpdateRelease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_UpdateRelease_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_UpdateRelease_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_ReleaseService_InstallRelease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_InstallRelease_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_InstallRelease_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("DELETE", pattern_ReleaseService_UninstallRelease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_UninstallRelease_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_UninstallRelease_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_ReleaseService_GetVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_GetVersion_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_GetVersion_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("DELETE", pattern_ReleaseService_RollbackRelease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_RollbackRelease_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_RollbackRelease_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_ReleaseService_GetHistory_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_GetHistory_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_GetHistory_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_ReleaseService_RunReleaseTest_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
}
resp, md, err := request_ReleaseService_RunReleaseTest_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_ReleaseService_RunReleaseTest_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_ReleaseService_ListReleases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"tiller", "v2", "releases", "json"}, ""))
pattern_ReleaseService_GetReleaseStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 2, 7}, []string{"tiller", "v2", "releases", "name", "versions", "version", "status", "json"}, ""))
pattern_ReleaseService_GetReleaseContent_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 2, 7}, []string{"tiller", "v2", "releases", "name", "versions", "version", "content", "json"}, ""))
pattern_ReleaseService_UpdateRelease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"tiller", "v2", "releases", "name", "json"}, ""))
pattern_ReleaseService_InstallRelease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"tiller", "v2", "releases", "name", "json"}, ""))
pattern_ReleaseService_UninstallRelease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"tiller", "v2", "releases", "name", "json"}, ""))
pattern_ReleaseService_GetVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"tiller", "v2", "version", "json"}, ""))
pattern_ReleaseService_RollbackRelease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5, 2, 6, 2, 7}, []string{"tiller", "v2", "releases", "name", "versions", "version", "content", "json"}, ""))
pattern_ReleaseService_GetHistory_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"tiller", "v2", "releases", "name", "json"}, ""))
pattern_ReleaseService_RunReleaseTest_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 2, 5, 2, 6}, []string{"tiller", "v2", "releases", "name", "actions", "test", "json"}, ""))
)
var (
forward_ReleaseService_ListReleases_0 = runtime.ForwardResponseStream
forward_ReleaseService_GetReleaseStatus_0 = runtime.ForwardResponseMessage
forward_ReleaseService_GetReleaseContent_0 = runtime.ForwardResponseMessage
forward_ReleaseService_UpdateRelease_0 = runtime.ForwardResponseMessage
forward_ReleaseService_InstallRelease_0 = runtime.ForwardResponseMessage
forward_ReleaseService_UninstallRelease_0 = runtime.ForwardResponseMessage
forward_ReleaseService_GetVersion_0 = runtime.ForwardResponseMessage
forward_ReleaseService_RollbackRelease_0 = runtime.ForwardResponseMessage
forward_ReleaseService_GetHistory_0 = runtime.ForwardResponseMessage
forward_ReleaseService_RunReleaseTest_0 = runtime.ForwardResponseStream
)

@ -40,6 +40,27 @@ func (m *Version) String() string { return proto.CompactTextString(m)
func (*Version) ProtoMessage() {}
func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Version) GetSemVer() string {
if m != nil {
return m.SemVer
}
return ""
}
func (m *Version) GetGitCommit() string {
if m != nil {
return m.GitCommit
}
return ""
}
func (m *Version) GetGitTreeState() string {
if m != nil {
return m.GitTreeState
}
return ""
}
func init() {
proto.RegisterType((*Version)(nil), "hapi.version.Version")
}
@ -48,7 +69,7 @@ func init() { proto.RegisterFile("hapi/version/version.proto", fileDescriptor0)
var fileDescriptor0 = []byte{
// 151 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x48, 0x2c, 0xc8,
0xd4, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x83, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9,
0x42, 0x3c, 0x20, 0x39, 0x3d, 0xa8, 0x98, 0x52, 0x3a, 0x17, 0x7b, 0x18, 0x84, 0x29, 0x24, 0xce,
0xc5, 0x5e, 0x9c, 0x9a, 0x1b, 0x5f, 0x96, 0x5a, 0x24, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0xc4,

Loading…
Cancel
Save