iSharkFly-Docs
/
packer-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #7484 from yandex-cloud/yandex-cloud-builder 

Builder for Yandex.Cloud
This commit is contained in:
Adrien Delorme 2019-04-15 14:02:43 +02:00 committed by GitHub
parent 78cf1405ab ae0d8b78e9
commit 97f2914c6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
234 changed files with 79288 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CODEOWNERS
View File

@ -17,6 +17,7 @@
/builder/scaleway/ @sieben @mvaude @jqueuniet @fflorens @brmzkw
/builder/hcloud/ @LKaemmerling
/builder/hyperone @m110 @gregorybrzeski @ad-m
/builder/yandex @GennadySpb @alexanderKhaustov @seukyaso
# provisioners
@ -24,6 +25,7 @@
/provisioner/converge/ @stevendborrelli
# post-processors
/post-processor/alicloud-import/ dongxiao.zzh@alibaba-inc.com
/post-processor/checksum/ v.tolstov@selfip.ru
/post-processor/googlecompute-export/ crunkleton@google.com

46
builder/yandex/artifact.go Normal file
View File

@ -0,0 +1,46 @@
package yandex
import (
"fmt"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
)
type Artifact struct {
config *Config
driver Driver
image *compute.Image
}
//revive:disable:var-naming
func (*Artifact) BuilderId() string {
return BuilderID
}
func (a *Artifact) Id() string {
return a.image.Id
}
func (*Artifact) Files() []string {
return nil
}
//revive:enable:var-naming
func (a *Artifact) String() string {
return fmt.Sprintf("A disk image was created: %v (id: %v) with family name %v", a.image.Name, a.image.Id, a.image.Family)
}
func (a *Artifact) State(name string) interface{} {
switch name {
case "ImageID":
return a.image.Id
case "FolderID":
return a.image.FolderId
}
return nil
}
func (a *Artifact) Destroy() error {
return a.driver.DeleteImage(a.image.Id)
}

43
builder/yandex/artifact_test.go Normal file
View File

@ -0,0 +1,43 @@
package yandex
import (
"testing"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
)
func TestArtifact_impl(t *testing.T) {
var _ packer.Artifact = new(Artifact)
}
func TestArtifact_Id(t *testing.T) {
i := &compute.Image{
Id: "test-id-value",
FolderId: "test-folder-id",
}
a := &Artifact{
image: i}
expected := "test-id-value"
if a.Id() != expected {
t.Fatalf("artifact ID should match: %v", expected)
}
}
func TestArtifact_String(t *testing.T) {
i := &compute.Image{
Id: "test-id-value",
FolderId: "test-folder-id",
Name: "test-name",
Family: "test-family",
}
a := &Artifact{
image: i}
expected := "A disk image was created: test-name (id: test-id-value) with family name test-family"
if a.String() != expected {
t.Fatalf("artifact string should match: %v", expected)
}
}

94
builder/yandex/builder.go Normal file
View File

@ -0,0 +1,94 @@
package yandex
import (
"context"
"fmt"
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
)
// The unique ID for this builder.
const BuilderID = "packer.yandex"
// Builder represents a Packer Builder.
type Builder struct {
config *Config
runner multistep.Runner
}
// Prepare processes the build configuration parameters.
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
c, warnings, errs := NewConfig(raws...)
if errs != nil {
return warnings, errs
}
b.config = c
return warnings, nil
}
// Run executes a yandex Packer build and returns a packer.Artifact
// representing a Yandex.Cloud compute image.
func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
driver, err := NewDriverYC(ui, b.config)
if err != nil {
return nil, err
}
// Set up the state
state := &multistep.BasicStateBag{}
state.Put("config", b.config)
state.Put("driver", driver)
state.Put("sdk", driver.SDK())
state.Put("hook", hook)
state.Put("ui", ui)
// Build the steps
steps := []multistep.Step{
&stepCreateSSHKey{
Debug: b.config.PackerDebug,
DebugKeyPath: fmt.Sprintf("yc_%s.pem", b.config.PackerBuildName),
},
&stepCreateInstance{
Debug: b.config.PackerDebug,
SerialLogFile: b.config.SerialLogFile,
},
&stepInstanceInfo{},
&communicator.StepConnect{
Config: &b.config.Communicator,
Host: commHost,
SSHConfig: b.config.Communicator.SSHConfigFunc(),
},
&common.StepProvision{},
&common.StepCleanupTempKeys{
Comm: &b.config.Communicator,
},
&stepTeardownInstance{},
&stepCreateImage{},
}
// Run the steps
b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
b.runner.Run(ctx, state)
// Report any errors
if rawErr, ok := state.GetOk("error"); ok {
return nil, rawErr.(error)
}
image, ok := state.GetOk("image")
if !ok {
return nil, fmt.Errorf("Failed to find 'image' in state. Bug?")
}
artifact := &Artifact{
image: image.(*compute.Image),
config: b.config,
}
return artifact, nil
}

36
builder/yandex/builder_acc_test.go Normal file
View File

@ -0,0 +1,36 @@
package yandex
import (
"os"
"testing"
builderT "github.com/hashicorp/packer/helper/builder/testing"
)
func TestBuilderAcc_basic(t *testing.T) {
builderT.Test(t, builderT.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Builder: &Builder{},
Template: testBuilderAccBasic,
})
}
func testAccPreCheck(t *testing.T) {
if v := os.Getenv("YC_TOKEN"); v == "" {
t.Fatal("YC_TOKEN must be set for acceptance tests")
}
if v := os.Getenv("YC_FOLDER_ID"); v == "" {
t.Fatal("YC_FOLDER_ID must be set for acceptance tests")
}
}
const testBuilderAccBasic = `
{
"builders": [{
"type": "test",
"source_image_family": "ubuntu-1804-lts",
"use_ipv4_nat": "true",
"ssh_username": "ubuntu"
}]
}
`

14
builder/yandex/builder_test.go Normal file
View File

@ -0,0 +1,14 @@
package yandex
import (
"testing"
"github.com/hashicorp/packer/packer"
)
func TestBuilder_ImplementsBuilder(t *testing.T) {
var raw interface{} = &Builder{}
if _, ok := raw.(packer.Builder); !ok {
t.Fatalf("Builder should be a builder")
}
}

205
builder/yandex/config.go Normal file
View File

@ -0,0 +1,205 @@
package yandex
import (
"errors"
"fmt"
"os"
"regexp"
"time"
"github.com/hashicorp/packer/common"
"github.com/hashicorp/packer/common/uuid"
"github.com/hashicorp/packer/helper/communicator"
"github.com/hashicorp/packer/helper/config"
"github.com/hashicorp/packer/packer"
"github.com/hashicorp/packer/template/interpolate"
"github.com/yandex-cloud/go-sdk/iamkey"
)
const defaultEndpoint = "api.cloud.yandex.net:443"
const defaultZone = "ru-central1-a"
var reImageFamily = regexp.MustCompile(`^[a-z]([-a-z0-9]{0,61}[a-z0-9])?$`)
type Config struct {
common.PackerConfig `mapstructure:",squash"`
Communicator communicator.Config `mapstructure:",squash"`
Endpoint string `mapstructure:"endpoint"`
FolderID string `mapstructure:"folder_id"`
ServiceAccountKeyFile string `mapstructure:"service_account_key_file"`
Token string `mapstructure:"token"`
DiskName string `mapstructure:"disk_name"`
DiskSizeGb int `mapstructure:"disk_size_gb"`
DiskType string `mapstructure:"disk_type"`
ImageDescription string `mapstructure:"image_description"`
ImageFamily string `mapstructure:"image_family"`
ImageLabels map[string]string `mapstructure:"image_labels"`
ImageName string `mapstructure:"image_name"`
ImageProductIDs []string `mapstructure:"image_product_ids"`
InstanceCores int `mapstructure:"instance_cores"`
InstanceMemory int `mapstructure:"instance_mem_gb"`
InstanceName string `mapstructure:"instance_name"`
Labels map[string]string `mapstructure:"labels"`
PlatformID string `mapstructure:"platform_id"`
Metadata map[string]string `mapstructure:"metadata"`
SerialLogFile string `mapstructure:"serial_log_file"`
SourceImageFamily string `mapstructure:"source_image_family"`
SourceImageFolderID string `mapstructure:"source_image_folder_id"`
SourceImageID string `mapstructure:"source_image_id"`
SubnetID string `mapstructure:"subnet_id"`
UseIPv4Nat bool `mapstructure:"use_ipv4_nat"`
UseIPv6 bool `mapstructure:"use_ipv6"`
UseInternalIP bool `mapstructure:"use_internal_ip"`
Zone string `mapstructure:"zone"`
ctx interpolate.Context
StateTimeout time.Duration `mapstructure:"state_timeout"`
}
func NewConfig(raws ...interface{}) (*Config, []string, error) {
c := &Config{}
c.ctx.Funcs = TemplateFuncs
err := config.Decode(c, &config.DecodeOpts{
Interpolate: true,
InterpolateContext: &c.ctx,
}, raws...)
if err != nil {
return nil, nil, err
}
var errs *packer.MultiError
if c.SerialLogFile != "" {
if _, err := os.Stat(c.SerialLogFile); os.IsExist(err) {
errs = packer.MultiErrorAppend(errs,
fmt.Errorf("Serial log file %s already exist", c.SerialLogFile))
}
}
if c.InstanceCores == 0 {
c.InstanceCores = 2
}
if c.InstanceMemory == 0 {
c.InstanceMemory = 4
}
if c.DiskSizeGb == 0 {
c.DiskSizeGb = 10
}
if c.DiskType == "" {
c.DiskType = "network-hdd"
}
if c.ImageDescription == "" {
c.ImageDescription = "Created by Packer"
}
if c.ImageName == "" {
img, err := interpolate.Render("packer-{{timestamp}}", nil)
if err != nil {
errs = packer.MultiErrorAppend(errs,
fmt.Errorf("Unable to render default image name: %s ", err))
} else {
c.ImageName = img
}
}
if len(c.ImageFamily) > 63 {
errs = packer.MultiErrorAppend(errs,
errors.New("Invalid image family: Must not be longer than 63 characters"))
}
if c.ImageFamily != "" {
if !reImageFamily.MatchString(c.ImageFamily) {
errs = packer.MultiErrorAppend(errs,
errors.New("Invalid image family: The first character must be a "+
"lowercase letter, and all following characters must be a dash, "+
"lowercase letter, or digit, except the last character, which cannot be a dash"))
}
}
if c.InstanceName == "" {
c.InstanceName = fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
}
if c.DiskName == "" {
c.DiskName = c.InstanceName + "-disk"
}
if c.PlatformID == "" {
c.PlatformID = "standard-v1"
}
if es := c.Communicator.Prepare(&c.ctx); len(es) > 0 {
errs = packer.MultiErrorAppend(errs, es...)
}
// Process required parameters.
if c.SourceImageID == "" && c.SourceImageFamily == "" {
errs = packer.MultiErrorAppend(
errs, errors.New("a source_image_id or source_image_family must be specified"))
}
if c.Endpoint == "" {
c.Endpoint = defaultEndpoint
}
if c.Zone == "" {
c.Zone = defaultZone
}
// provision config by OS environment variables
if c.Token == "" {
c.Token = os.Getenv("YC_TOKEN")
}
if c.ServiceAccountKeyFile == "" {
c.ServiceAccountKeyFile = os.Getenv("YC_SERVICE_ACCOUNT_KEY_FILE")
}
if c.FolderID == "" {
c.FolderID = os.Getenv("YC_FOLDER_ID")
}
if c.Token == "" && c.ServiceAccountKeyFile == "" {
errs = packer.MultiErrorAppend(
errs, errors.New("a token or service account key file must be specified"))
}
if c.Token != "" && c.ServiceAccountKeyFile != "" {
errs = packer.MultiErrorAppend(
errs, errors.New("one of token or service account key file must be specified, not both"))
}
if c.Token != "" {
packer.LogSecretFilter.Set(c.Token)
}
if c.ServiceAccountKeyFile != "" {
if _, err := iamkey.ReadFromJSONFile(c.ServiceAccountKeyFile); err != nil {
errs = packer.MultiErrorAppend(
errs, fmt.Errorf("fail to read service account key file: %s", err))
}
}
if c.FolderID == "" {
errs = packer.MultiErrorAppend(
errs, errors.New("a folder_id must be specified"))
}
if c.StateTimeout == 0 {
c.StateTimeout = 5 * time.Minute
}
// Check for any errors.
if errs != nil && len(errs.Errors) > 0 {
return nil, nil, errs
}
return c, nil, nil
}

231
builder/yandex/config_test.go Normal file
View File

@ -0,0 +1,231 @@
package yandex
import (
"io/ioutil"
"os"
"strings"
"testing"
)
const TestServiceAccountKeyFile = "./test_data/fake-sa-key.json"
func TestConfigPrepare(t *testing.T) {
tf, err := ioutil.TempFile("", "packer")
if err != nil {
t.Fatalf("err: %s", err)
}
defer os.Remove(tf.Name())
tf.Close()
cases := []struct {
Key string
Value interface{}
Err bool
}{
{
"unknown_key",
"bad",
true,
},
{
"service_account_key_file",
"/tmp/i/should/not/exist",
true,
},
{
"service_account_key_file",
tf.Name(),
true,
},
{
"service_account_key_file",
TestServiceAccountKeyFile,
false,
},
{
"folder_id",
nil,
true,
},
{
"folder_id",
"foo",
false,
},
{
"source_image_id",
nil,
true,
},
{
"source_image_id",
"foo",
false,
},
{
"source_image_family",
nil,
false,
},
{
"source_image_family",
"foo",
false,
},
{
"zone",
nil,
false,
},
{
"zone",
"foo",
false,
},
{
"ssh_timeout",
"SO BAD",
true,
},
{
"ssh_timeout",
"5s",
false,
},
{
"image_family",
nil,
false,
},
{
"image_family",
"",
false,
},
{
"image_family",
"foo-bar",
false,
},
{
"image_family",
"foo bar",
true,
},
}
for _, tc := range cases {
raw := testConfig(t)
if tc.Value == nil {
delete(raw, tc.Key)
} else {
raw[tc.Key] = tc.Value
}
if tc.Key == "service_account_key_file" {
delete(raw, "token")
}
_, warns, errs := NewConfig(raw)
if tc.Err {
testConfigErr(t, warns, errs, tc.Key)
} else {
testConfigOk(t, warns, errs)
}
}
}
func TestConfigDefaults(t *testing.T) {
cases := []struct {
Read func(c *Config) interface{}
Value interface{}
}{
{
func(c *Config) interface{} { return c.Communicator.Type },
"ssh",
},
{
func(c *Config) interface{} { return c.Communicator.SSHPort },
22,
},
}
for _, tc := range cases {
raw := testConfig(t)
c, warns, errs := NewConfig(raw)
testConfigOk(t, warns, errs)
actual := tc.Read(c)
if actual != tc.Value {
t.Fatalf("bad: %#v", actual)
}
}
}
func TestImageName(t *testing.T) {
raw := testConfig(t)
c, _, _ := NewConfig(raw)
if !strings.HasPrefix(c.ImageName, "packer-") {
t.Fatalf("ImageName should have 'packer-' prefix, found %s", c.ImageName)
}
if strings.Contains(c.ImageName, "{{timestamp}}") {
t.Errorf("ImageName should be interpolated; found %s", c.ImageName)
}
}
func TestZone(t *testing.T) {
raw := testConfig(t)
c, _, _ := NewConfig(raw)
if c.Zone != "ru-central1-a" {
t.Fatalf("Zone should be 'ru-central1-a' given, but is '%s'", c.Zone)
}
}
// Helper stuff below
func testConfig(t *testing.T) (config map[string]interface{}) {
config = map[string]interface{}{
"token": "test_token",
"folder_id": "hashicorp",
"source_image_id": "foo",
"ssh_username": "root",
"image_family": "bar",
"image_product_ids": []string{
"test-license",
},
"zone": "ru-central1-a",
}
return config
}
func testConfigErr(t *testing.T, warns []string, err error, extra string) {
if len(warns) > 0 {
t.Fatalf("bad: %#v", warns)
}
if err == nil {
t.Fatalf("should error: %s", extra)
}
}
func testConfigOk(t *testing.T, warns []string, err error) {
if len(warns) > 0 {
t.Fatalf("bad: %#v", warns)
}
if err != nil {
t.Fatalf("bad: %s", err)
}
}

18
builder/yandex/driver.go Normal file
View File

@ -0,0 +1,18 @@
package yandex
import (
"context"
ycsdk "github.com/yandex-cloud/go-sdk"
)
type Driver interface {
DeleteImage(id string) error
SDK() *ycsdk.SDK
GetImage(imageID string) (*Image, error)
GetImageFromFolder(ctx context.Context, folderID string, family string) (*Image, error)
DeleteDisk(ctx context.Context, diskID string) error
DeleteInstance(ctx context.Context, instanceID string) error
DeleteSubnet(ctx context.Context, subnetID string) error
DeleteNetwork(ctx context.Context, networkID string) error
}

203
builder/yandex/driver_yc.go Normal file
View File

@ -0,0 +1,203 @@
package yandex
import (
"context"
"log"
"github.com/hashicorp/packer/helper/useragent"
"github.com/hashicorp/packer/packer"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
"github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint"
"github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1"
ycsdk "github.com/yandex-cloud/go-sdk"
"github.com/yandex-cloud/go-sdk/iamkey"
"github.com/yandex-cloud/go-sdk/pkg/requestid"
)
type driverYC struct {
sdk *ycsdk.SDK
ui packer.Ui
}
func NewDriverYC(ui packer.Ui, config *Config) (Driver, error) {
log.Printf("[INFO] Initialize Yandex.Cloud client...")
sdkConfig := ycsdk.Config{}
if config.Endpoint != "" {
sdkConfig.Endpoint = config.Endpoint
}
switch {
case config.Token != "":
sdkConfig.Credentials = ycsdk.OAuthToken(config.Token)
case config.ServiceAccountKeyFile != "":
key, err := iamkey.ReadFromJSONFile(config.ServiceAccountKeyFile)
if err != nil {
return nil, err
}
credentials, err := ycsdk.ServiceAccountKey(key)
if err != nil {
return nil, err
}
sdkConfig.Credentials = credentials
}
userAgentMD := metadata.Pairs("user-agent", useragent.String())
sdk, err := ycsdk.Build(context.Background(), sdkConfig,
grpc.WithDefaultCallOptions(grpc.Header(&userAgentMD)),
grpc.WithUnaryInterceptor(requestid.Interceptor()))
if err != nil {
return nil, err
}
if _, err = sdk.ApiEndpoint().ApiEndpoint().List(context.Background(), &endpoint.ListApiEndpointsRequest{}); err != nil {
return nil, err
}
return &driverYC{
sdk: sdk,
ui: ui,
}, nil
}
func (d *driverYC) GetImage(imageID string) (*Image, error) {
image, err := d.sdk.Compute().Image().Get(context.Background(), &compute.GetImageRequest{
ImageId: imageID,
})
if err != nil {
return nil, err
}
return &Image{
ID: image.Id,
Labels: image.Labels,
Licenses: image.ProductIds,
Name: image.Name,
FolderID: image.FolderId,
MinDiskSizeGb: toGigabytes(image.MinDiskSize),
SizeGb: toGigabytes(image.StorageSize),
}, nil
}
func (d *driverYC) GetImageFromFolder(ctx context.Context, folderID string, family string) (*Image, error) {
image, err := d.sdk.Compute().Image().GetLatestByFamily(ctx, &compute.GetImageLatestByFamilyRequest{
FolderId: folderID,
Family: family,
})
if err != nil {
return nil, err
}
return &Image{
ID: image.Id,
Labels: image.Labels,
Licenses: image.ProductIds,
Name: image.Name,
FolderID: image.FolderId,
Family: image.Family,
MinDiskSizeGb: toGigabytes(image.MinDiskSize),
SizeGb: toGigabytes(image.StorageSize),
}, nil
}
func (d *driverYC) DeleteImage(ID string) error {
ctx := context.TODO()
op, err := d.sdk.WrapOperation(d.sdk.Compute().Image().Delete(ctx, &compute.DeleteImageRequest{
ImageId: ID,
}))
if err != nil {
return err
}
err = op.Wait(ctx)
if err != nil {
return err
}
_, err = op.Response()
return err
}
func (d *driverYC) SDK() *ycsdk.SDK {
return d.sdk
}
func (d *driverYC) DeleteInstance(ctx context.Context, instanceID string) error {
op, err := d.sdk.WrapOperation(d.sdk.Compute().Instance().Delete(ctx, &compute.DeleteInstanceRequest{
InstanceId: instanceID,
}))
if err != nil {
return err
}
err = op.Wait(ctx)
if err != nil {
return err
}
_, err = op.Response()
return err
}
func (d *driverYC) DeleteSubnet(ctx context.Context, subnetID string) error {
op, err := d.sdk.WrapOperation(d.sdk.VPC().Subnet().Delete(ctx, &vpc.DeleteSubnetRequest{
SubnetId: subnetID,
}))
if err != nil {
return err
}
err = op.Wait(ctx)
if err != nil {
return err
}
_, err = op.Response()
return err
}
func (d *driverYC) DeleteNetwork(ctx context.Context, networkID string) error {
op, err := d.sdk.WrapOperation(d.sdk.VPC().Network().Delete(ctx, &vpc.DeleteNetworkRequest{
NetworkId: networkID,
}))
if err != nil {
return err
}
err = op.Wait(ctx)
if err != nil {
return err
}
_, err = op.Response()
return err
}
func (d *driverYC) DeleteDisk(ctx context.Context, diskID string) error {
op, err := d.sdk.WrapOperation(d.sdk.Compute().Disk().Delete(ctx, &compute.DeleteDiskRequest{
DiskId: diskID,
}))
if err != nil {
return err
}
err = op.Wait(ctx)
if err != nil {
return err
}
_, err = op.Response()
return err
}

12
builder/yandex/image.go Normal file
View File

@ -0,0 +1,12 @@
package yandex
type Image struct {
ID string
FolderID string
Labels map[string]string
Licenses []string
MinDiskSizeGb int
Name string
Family string
SizeGb int
}

10
builder/yandex/ssh.go Normal file
View File

@ -0,0 +1,10 @@
package yandex
import (
"github.com/hashicorp/packer/helper/multistep"
)
func commHost(state multistep.StateBag) (string, error) {
ipAddress := state.Get("instance_ip").(string)
return ipAddress, nil
}

70
builder/yandex/step_create_image.go Normal file
View File

@ -0,0 +1,70 @@
package yandex
import (
"context"
"errors"
"fmt"
"log"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
ycsdk "github.com/yandex-cloud/go-sdk"
)
type stepCreateImage struct{}
func (stepCreateImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
sdk := state.Get("sdk").(*ycsdk.SDK)
ui := state.Get("ui").(packer.Ui)
c := state.Get("config").(*Config)
diskID := state.Get("disk_id").(string)
ui.Say(fmt.Sprintf("Creating image: %v", c.ImageName))
ctx, cancel := context.WithTimeout(ctx, c.StateTimeout)
defer cancel()
op, err := sdk.WrapOperation(sdk.Compute().Image().Create(ctx, &compute.CreateImageRequest{
FolderId: c.FolderID,
Name: c.ImageName,
Family: c.ImageFamily,
Description: c.ImageDescription,
Labels: c.ImageLabels,
ProductIds: c.ImageProductIDs,
Source: &compute.CreateImageRequest_DiskId{
DiskId: diskID,
},
}))
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error creating image: %s", err))
}
ui.Say("Waiting for image to complete...")
if err := op.Wait(ctx); err != nil {
return stepHaltWithError(state, fmt.Errorf("Error waiting for image: %s", err))
}
resp, err := op.Response()
if err != nil {
return stepHaltWithError(state, err)
}
image, ok := resp.(*compute.Image)
if !ok {
return stepHaltWithError(state, errors.New("Response doesn't contain Image"))
}
log.Printf("Image ID: %s", image.Id)
log.Printf("Image Name: %s", image.Name)
log.Printf("Image Family: %s", image.Family)
log.Printf("Image Description: %s", image.Description)
log.Printf("Image Storage size: %d", image.StorageSize)
state.Put("image", image)
return multistep.ActionContinue
}
func (stepCreateImage) Cleanup(state multistep.StateBag) {
// no cleanup
}

357
builder/yandex/step_create_instance.go Normal file
View File

@ -0,0 +1,357 @@
package yandex
import (
"context"
"errors"
"fmt"
"io/ioutil"
"github.com/c2h5oh/datasize"
"github.com/hashicorp/packer/common/uuid"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
"github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1"
ycsdk "github.com/yandex-cloud/go-sdk"
)
const StandardImagesFolderID = "standard-images"
type stepCreateInstance struct {
Debug bool
SerialLogFile string
}
func createNetwork(ctx context.Context, c *Config, d Driver) (*vpc.Network, error) {
req := &vpc.CreateNetworkRequest{
FolderId: c.FolderID,
Name: fmt.Sprintf("packer-network-%s", uuid.TimeOrderedUUID()),
}
sdk := d.SDK()
op, err := sdk.WrapOperation(sdk.VPC().Network().Create(ctx, req))
if err != nil {
return nil, err
}
err = op.Wait(ctx)
if err != nil {
return nil, err
}
resp, err := op.Response()
if err != nil {
return nil, err
}
network, ok := resp.(*vpc.Network)
if !ok {
return nil, errors.New("network create operation response doesn't contain Network")
}
return network, nil
}
func createSubnet(ctx context.Context, c *Config, d Driver, networkID string) (*vpc.Subnet, error) {
req := &vpc.CreateSubnetRequest{
FolderId: c.FolderID,
NetworkId: networkID,
Name: fmt.Sprintf("packer-subnet-%s", uuid.TimeOrderedUUID()),
ZoneId: c.Zone,
V4CidrBlocks: []string{"192.168.111.0/24"},
}
sdk := d.SDK()
op, err := sdk.WrapOperation(sdk.VPC().Subnet().Create(ctx, req))
if err != nil {
return nil, err
}
err = op.Wait(ctx)
if err != nil {
return nil, err
}
resp, err := op.Response()
if err != nil {
return nil, err
}
subnet, ok := resp.(*vpc.Subnet)
if !ok {
return nil, errors.New("subnet create operation response doesn't contain Subnet")
}
return subnet, nil
}
func getImage(ctx context.Context, c *Config, d Driver) (*Image, error) {
if c.SourceImageID != "" {
return d.GetImage(c.SourceImageID)
}
familyName := c.SourceImageFamily
if c.SourceImageFolderID != "" {
return d.GetImageFromFolder(ctx, c.SourceImageFolderID, familyName)
}
return d.GetImageFromFolder(ctx, StandardImagesFolderID, familyName)
}
func (s *stepCreateInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
sdk := state.Get("sdk").(*ycsdk.SDK)
ui := state.Get("ui").(packer.Ui)
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ctx, cancel := context.WithTimeout(ctx, config.StateTimeout)
defer cancel()
sourceImage, err := getImage(ctx, config, driver)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error getting source image for instance creation: %s", err))
}
if sourceImage.MinDiskSizeGb > config.DiskSizeGb {
return stepHaltWithError(state, fmt.Errorf("Instance DiskSizeGb (%d) should be equal or greater "+
"than SourceImage disk requirement (%d)", config.DiskSizeGb, sourceImage.MinDiskSizeGb))
}
ui.Say(fmt.Sprintf("Using as source image: %s (name: %q, family: %q)", sourceImage.ID, sourceImage.Name, sourceImage.Family))
// create or reuse network configuration
instanceSubnetID := ""
if config.SubnetID == "" {
// create Network and Subnet
ui.Say("Creating network...")
network, err := createNetwork(ctx, config, driver)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error creating network: %s", err))
}
state.Put("network_id", network.Id)
ui.Say(fmt.Sprintf("Creating subnet in zone %q...", config.Zone))
subnet, err := createSubnet(ctx, config, driver, network.Id)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error creating subnet: %s", err))
}
instanceSubnetID = subnet.Id
// save for cleanup
state.Put("subnet_id", subnet.Id)
} else {
ui.Say("Use provided subnet id " + config.SubnetID)
instanceSubnetID = config.SubnetID
}
// Create an instance based on the configuration
ui.Say("Creating instance...")
instanceMetadata := config.createInstanceMetadata(string(config.Communicator.SSHPublicKey))
// TODO make part metadata prepare process
if config.UseIPv6 {
// this ugly hack will replace user provided 'user-data'
userData := `#cloud-config
runcmd:
- [ sh, -c, '/sbin/dhclient -6 -D LL -nw -pf /run/dhclient_ipv6.eth0.pid -lf /var/lib/dhcp/dhclient_ipv6.eth0.leases eth0' ]
`
instanceMetadata["user-data"] = userData
}
req := &compute.CreateInstanceRequest{
FolderId: config.FolderID,
Name: config.InstanceName,
Labels: config.Labels,
ZoneId: config.Zone,
PlatformId: config.PlatformID,
ResourcesSpec: &compute.ResourcesSpec{
Memory: toBytes(config.InstanceMemory),
Cores: int64(config.InstanceCores),
},
Metadata: instanceMetadata,
BootDiskSpec: &compute.AttachedDiskSpec{
AutoDelete: false,
Disk: &compute.AttachedDiskSpec_DiskSpec_{
DiskSpec: &compute.AttachedDiskSpec_DiskSpec{
Name: config.DiskName,
TypeId: config.DiskType,
Size: int64((datasize.ByteSize(config.DiskSizeGb) * datasize.GB).Bytes()),
Source: &compute.AttachedDiskSpec_DiskSpec_ImageId{
ImageId: sourceImage.ID,
},
},
},
},
NetworkInterfaceSpecs: []*compute.NetworkInterfaceSpec{
{
SubnetId: instanceSubnetID,
PrimaryV4AddressSpec: &compute.PrimaryAddressSpec{},
},
},
}
if config.UseIPv6 {
req.NetworkInterfaceSpecs[0].PrimaryV6AddressSpec = &compute.PrimaryAddressSpec{}
}
if config.UseIPv4Nat {
req.NetworkInterfaceSpecs[0].PrimaryV4AddressSpec = &compute.PrimaryAddressSpec{
OneToOneNatSpec: &compute.OneToOneNatSpec{
IpVersion: compute.IpVersion_IPV4,
},
}
}
op, err := sdk.WrapOperation(sdk.Compute().Instance().Create(ctx, req))
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error create instance: %s", err))
}
opMetadata, err := op.Metadata()
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error get create operation metadata: %s", err))
}
if cimd, ok := opMetadata.(*compute.CreateInstanceMetadata); ok {
state.Put("instance_id", cimd.InstanceId)
} else {
return stepHaltWithError(state, fmt.Errorf("could not get Instance ID from operation metadata"))
}
err = op.Wait(ctx)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error create instance: %s", err))
}
resp, err := op.Response()
if err != nil {
return stepHaltWithError(state, err)
}
instance, ok := resp.(*compute.Instance)
if !ok {
return stepHaltWithError(state, fmt.Errorf("response doesn't contain Instance"))
}
state.Put("disk_id", instance.BootDisk.DiskId)
if s.Debug {
ui.Message(fmt.Sprintf("Instance ID %s started. Current instance status %s", instance.Id, instance.Status))
ui.Message(fmt.Sprintf("Disk ID %s. ", instance.BootDisk.DiskId))
}
return multistep.ActionContinue
}
func (s *stepCreateInstance) Cleanup(state multistep.StateBag) {
config := state.Get("config").(*Config)
driver := state.Get("driver").(Driver)
ui := state.Get("ui").(packer.Ui)
ctx, cancel := context.WithTimeout(context.Background(), config.StateTimeout)
defer cancel()
if s.SerialLogFile != "" {
ui.Say("Current state 'cancelled' or 'halted'...")
err := s.writeSerialLogFile(ctx, state)
if err != nil {
ui.Error(err.Error())
}
}
instanceIDRaw, ok := state.GetOk("instance_id")
if ok {
instanceID := instanceIDRaw.(string)
if instanceID != "" {
ui.Say("Destroying instance...")
err := driver.DeleteInstance(ctx, instanceID)
if err != nil {
ui.Error(fmt.Sprintf(
"Error destroying instance (id: %s). Please destroy it manually: %s", instanceID, err))
}
ui.Message("Instance has been destroyed!")
}
}
subnetIDRaw, ok := state.GetOk("subnet_id")
if ok {
subnetID := subnetIDRaw.(string)
if subnetID != "" {
// Destroy the subnet we just created
ui.Say("Destroying subnet...")
err := driver.DeleteSubnet(ctx, subnetID)
if err != nil {
ui.Error(fmt.Sprintf(
"Error destroying subnet (id: %s). Please destroy it manually: %s", subnetID, err))
}
ui.Message("Subnet has been deleted!")
}
}
// Destroy the network we just created
networkIDRaw, ok := state.GetOk("network_id")
if ok {
networkID := networkIDRaw.(string)
if networkID != "" {
// Destroy the network we just created
ui.Say("Destroying network...")
err := driver.DeleteNetwork(ctx, networkID)
if err != nil {
ui.Error(fmt.Sprintf(
"Error destroying network (id: %s). Please destroy it manually: %s", networkID, err))
}
ui.Message("Network has been deleted!")
}
}
diskIDRaw, ok := state.GetOk("disk_id")
if ok {
ui.Say("Destroying boot disk...")
diskID := diskIDRaw.(string)
err := driver.DeleteDisk(ctx, diskID)
if err != nil {
ui.Error(fmt.Sprintf(
"Error destroying boot disk (id: %s). Please destroy it manually: %s", diskID, err))
}
ui.Message("Disk has been deleted!")
}
}
func (s *stepCreateInstance) writeSerialLogFile(ctx context.Context, state multistep.StateBag) error {
sdk := state.Get("sdk").(*ycsdk.SDK)
ui := state.Get("ui").(packer.Ui)
instanceID := state.Get("instance_id").(string)
ui.Say("Try get instance's serial port output and write to file " + s.SerialLogFile)
serialOutput, err := sdk.Compute().Instance().GetSerialPortOutput(ctx, &compute.GetInstanceSerialPortOutputRequest{
InstanceId: instanceID,
})
if err != nil {
return fmt.Errorf("Failed to get serial port output for instance (id: %s): %s", instanceID, err)
}
if err := ioutil.WriteFile(s.SerialLogFile, []byte(serialOutput.Contents), 0600); err != nil {
return fmt.Errorf("Failed to write serial port output to file: %s", err)
}
ui.Message("Serial port output has been successfully written")
return nil
}
func (c *Config) createInstanceMetadata(sshPublicKey string) map[string]string {
instanceMetadata := make(map[string]string)
// Copy metadata from config.
for k, v := range c.Metadata {
instanceMetadata[k] = v
}
if sshPublicKey != "" {
sshMetaKey := "ssh-keys"
sshKeys := fmt.Sprintf("%s:%s", c.Communicator.SSHUsername, sshPublicKey)
if confSSHKeys, exists := instanceMetadata[sshMetaKey]; exists {
sshKeys = fmt.Sprintf("%s\n%s", sshKeys, confSSHKeys)
}
instanceMetadata[sshMetaKey] = sshKeys
}
return instanceMetadata
}

100
builder/yandex/step_create_ssh_key.go Normal file
View File

@ -0,0 +1,100 @@
package yandex
import (
"context"
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"encoding/pem"
"fmt"
"io/ioutil"
"log"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"golang.org/x/crypto/ssh"
)
type stepCreateSSHKey struct {
Debug bool
DebugKeyPath string
}
func (s *stepCreateSSHKey) Run(_ context.Context, state multistep.StateBag) multistep.StepAction {
ui := state.Get("ui").(packer.Ui)
config := state.Get("config").(*Config)
if config.Communicator.SSHPrivateKeyFile != "" {
ui.Say("Using existing SSH private key")
privateKeyBytes, err := config.Communicator.ReadSSHPrivateKeyFile()
if err != nil {
state.Put("error", err)
return multistep.ActionHalt
}
key, err := ssh.ParsePrivateKey(privateKeyBytes)
if err != nil {
err = fmt.Errorf("Error parsing 'ssh_private_key_file': %s", err)
ui.Error(err.Error())
state.Put("error", err)
return multistep.ActionHalt
}
config.Communicator.SSHPublicKey = ssh.MarshalAuthorizedKey(key.PublicKey())
config.Communicator.SSHPrivateKey = privateKeyBytes
return multistep.ActionContinue
}
ui.Say("Creating temporary ssh key for instance...")
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error generating temporary SSH key: %s", err))
}
// ASN.1 DER encoded form
privDer := x509.MarshalPKCS1PrivateKey(priv)
privBlk := pem.Block{
Type: "RSA PRIVATE KEY",
Headers: nil,
Bytes: privDer,
}
// Marshal the public key into SSH compatible format
pub, err := ssh.NewPublicKey(&priv.PublicKey)
if err != nil {
err = fmt.Errorf("Error creating public ssh key: %s", err)
ui.Error(err.Error())
state.Put("error", err)
return multistep.ActionHalt
}
pubSSHFormat := string(ssh.MarshalAuthorizedKey(pub))
hashMD5 := ssh.FingerprintLegacyMD5(pub)
hashSHA256 := ssh.FingerprintSHA256(pub)
log.Printf("[INFO] md5 hash of ssh pub key: %s", hashMD5)
log.Printf("[INFO] sha256 hash of ssh pub key: %s", hashSHA256)
// Remember some state for the future
state.Put("ssh_key_public", pubSSHFormat)
// Set the private key in the config for later
config.Communicator.SSHPrivateKey = pem.EncodeToMemory(&privBlk)
config.Communicator.SSHPublicKey = ssh.MarshalAuthorizedKey(pub)
// If we're in debug mode, output the private key to the working directory.
if s.Debug {
ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath))
err := ioutil.WriteFile(s.DebugKeyPath, config.Communicator.SSHPrivateKey, 0600)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error saving debug key: %s", err))
}
}
return multistep.ActionContinue
}
func (s *stepCreateSSHKey) Cleanup(state multistep.StateBag) {
}

111
builder/yandex/step_instance_info.go Normal file
View File

@ -0,0 +1,111 @@
package yandex
import (
"context"
"errors"
"fmt"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
ycsdk "github.com/yandex-cloud/go-sdk"
)
type stepInstanceInfo struct{}
func (s *stepInstanceInfo) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
sdk := state.Get("sdk").(*ycsdk.SDK)
ui := state.Get("ui").(packer.Ui)
c := state.Get("config").(*Config)
instanceID := state.Get("instance_id").(string)
ui.Say("Waiting for instance to become active...")
ctx, cancel := context.WithTimeout(ctx, c.StateTimeout)
defer cancel()
instance, err := sdk.Compute().Instance().Get(ctx, &compute.GetInstanceRequest{
InstanceId: instanceID,
View: compute.InstanceView_FULL,
})
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error retrieving instance data: %s", err))
}
instanceIP, err := getInstanceIPAddress(c, instance)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Failed to find instance ip address: %s", err))
}
state.Put("instance_ip", instanceIP)
ui.Message(fmt.Sprintf("Detected instance IP: %s", instanceIP))
return multistep.ActionContinue
}
func getInstanceIPAddress(c *Config, instance *compute.Instance) (address string, err error) {
// Instance could have several network interfaces with different configuration each
// Get all possible addresses for instance
addrIPV4Internal, addrIPV4External, addrIPV6Addr, err := instanceAddresses(instance)
if err != nil {
return "", err
}
if c.UseIPv6 {
if addrIPV6Addr != "" {
return "[" + addrIPV6Addr + "]", nil
}
return "", errors.New("instance has no one IPv6 address")
}
if c.UseInternalIP {
if addrIPV4Internal != "" {
return addrIPV4Internal, nil
}
return "", errors.New("instance has no one IPv4 internal address")
}
if addrIPV4External != "" {
return addrIPV4External, nil
}
return "", errors.New("instance has no one IPv4 external address")
}
func instanceAddresses(instance *compute.Instance) (ipV4Int, ipV4Ext, ipV6 string, err error) {
if len(instance.NetworkInterfaces) == 0 {
return "", "", "", errors.New("No one network interface found for an instance")
}
var ipV4IntFound, ipV4ExtFound, ipV6Found bool
for _, iface := range instance.NetworkInterfaces {
if !ipV6Found && iface.PrimaryV6Address != nil {
ipV6 = iface.PrimaryV6Address.Address
ipV6Found = true
}
if !ipV4IntFound && iface.PrimaryV4Address != nil {
ipV4Int = iface.PrimaryV4Address.Address
ipV4IntFound = true
if !ipV4ExtFound && iface.PrimaryV4Address.OneToOneNat != nil {
ipV4Ext = iface.PrimaryV4Address.OneToOneNat.Address
ipV4ExtFound = true
}
}
if ipV6Found && ipV4IntFound && ipV4ExtFound {
break
}
}
if !ipV4IntFound {
// internal ipV4 address always should present
return "", "", "", errors.New("No IPv4 internal address found. Bug?")
}
return
}
func (s *stepInstanceInfo) Cleanup(state multistep.StateBag) {
// no cleanup
}

46
builder/yandex/step_teardown_instance.go Normal file
View File

@ -0,0 +1,46 @@
package yandex
import (
"context"
"fmt"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
"github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
ycsdk "github.com/yandex-cloud/go-sdk"
)
type stepTeardownInstance struct{}
func (s *stepTeardownInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
sdk := state.Get("sdk").(*ycsdk.SDK)
ui := state.Get("ui").(packer.Ui)
c := state.Get("config").(*Config)
instanceID := state.Get("instance_id").(string)
ui.Say("Deleting instance...")
ctx, cancel := context.WithTimeout(ctx, c.StateTimeout)
defer cancel()
op, err := sdk.WrapOperation(sdk.Compute().Instance().Delete(ctx, &compute.DeleteInstanceRequest{
InstanceId: instanceID,
}))
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error deleting instance: %s", err))
}
err = op.Wait(ctx)
if err != nil {
return stepHaltWithError(state, fmt.Errorf("Error deleting instance: %s", err))
}
ui.Message("Instance has been deleted!")
state.Put("instance_id", "")
return multistep.ActionContinue
}
func (s *stepTeardownInstance) Cleanup(state multistep.StateBag) {
// no cleanup
}

36
builder/yandex/template_func.go Normal file
View File

@ -0,0 +1,36 @@
package yandex
import "strings"
import "text/template"
func isalphanumeric(b byte) bool {
if '0' <= b && b <= '9' {
return true
}
if 'a' <= b && b <= 'z' {
return true
}
return false
}
// Clean up image name by replacing invalid characters with "-"
// and converting upper cases to lower cases
func templateCleanImageName(s string) string {
if reImageFamily.MatchString(s) {
return s
}
b := []byte(strings.ToLower(s))
newb := make([]byte, len(b))
for i := range newb {
if isalphanumeric(b[i]) {
newb[i] = b[i]
} else {
newb[i] = '-'
}
}
return string(newb)
}
var TemplateFuncs = template.FuncMap{
"clean_image_name": templateCleanImageName,
}

9
builder/yandex/test_data/fake-sa-key.json Normal file
View File

@ -0,0 +1,9 @@
{
"id": "ajeboa0du6edu6m43c3t",
"service_account_id": "ajeq7dsmihqple6761c5",
"created_at": "2018-11-19T13:38:09Z",
"description": "description",
"key_algorithm": "RSA_4096",
"public_key": "-----BEGIN PUBLIC KEY-----\nMIICCgKCAgEAo/s1lN5vFpFNJvS/l+yRilQHAPDeC3JqBwpLstbqJXW4kAUaKKoe\nxkIuJuPUKOUcd/JE3LXOEt/LOFb9mkCRdpjaIW7Jd5Fw0kTHIZ5rDoq7DZx0LV9b\nGJNskdccd6M6stb1GEqVuGpVcyXMCH8tMSG3c85DkcAg0cxXgyrirAzHMPiWSTpj\nJjICkxXRVj01Xq7dIDqL2LSMrZ2kLda5m+CnfscUbwnGRPPoEg20jLiEgBM2o43e\nhpWko1NStRR5fMQcQSUBbdtvbfPracjZz2/fq4fZfqlnObgq3WpYpdGynniLH3i5\nbxPM3ufYL3HY2w5aIOY6KIwMKLf3WYlug90ieviMYAvCukrCASwyqBQlt3MKCHlN\nIcebZXJDQ1VSBuEs+4qXYlhG1p+5C07zahzigNNTm6rEo47FFfClF04mv2uJN42F\nfWlEPR+V9JHBcfcBCdvyhiGzftl/vDo2NdO751ETIhyNKzxM/Ve2PR9h/qcuEatC\nLlXUA+40epNNHbSxAauxcngyrtkn7FZAEhdjyTtx46sELyb90Z56WgnbNUUGnsS/\nHBnBy5z8RyCmI5MjTC2NtplVqtAWkG+x59mU3GoCeuI8EaNtu2YPXhl1ovRkS4NB\n1G0F4c5FiJ27/E2MbNKlV5iw9ICcDforATYTeqiXbkkEKqIIiZYZWOsCAwEAAQ==\n-----END PUBLIC KEY-----\n",
"private_key": "-----BEGIN PRIVATE KEY-----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\n-----END PRIVATE KEY-----\n"
}

22
builder/yandex/util.go Normal file
View File

@ -0,0 +1,22 @@
package yandex
import (
"github.com/c2h5oh/datasize"
"github.com/hashicorp/packer/helper/multistep"
"github.com/hashicorp/packer/packer"
)
func stepHaltWithError(state multistep.StateBag, err error) multistep.StepAction {
ui := state.Get("ui").(packer.Ui)
state.Put("error", err)
ui.Error(err.Error())
return multistep.ActionHalt
}
func toGigabytes(bytesCount int64) int {
return int((datasize.ByteSize(bytesCount) * datasize.B).GBytes())
}
func toBytes(gigabytesCount int) int64 {
return int64((datasize.ByteSize(gigabytesCount) * datasize.GB).Bytes())
}

2
command/plugin.go
View File

@ -50,6 +50,7 @@ import (
virtualboxovfbuilder "github.com/hashicorp/packer/builder/virtualbox/ovf"
vmwareisobuilder "github.com/hashicorp/packer/builder/vmware/iso"
vmwarevmxbuilder "github.com/hashicorp/packer/builder/vmware/vmx"
yandexbuilder "github.com/hashicorp/packer/builder/yandex"
alicloudimportpostprocessor "github.com/hashicorp/packer/post-processor/alicloud-import"
amazonimportpostprocessor "github.com/hashicorp/packer/post-processor/amazon-import"
artificepostprocessor "github.com/hashicorp/packer/post-processor/artifice"
@ -129,6 +130,7 @@ var Builders = map[string]packer.Builder{
"virtualbox-ovf": new(virtualboxovfbuilder.Builder),
"vmware-iso": new(vmwareisobuilder.Builder),
"vmware-vmx": new(vmwarevmxbuilder.Builder),
"yandex": new(yandexbuilder.Builder),
}
var Provisioners = map[string]packer.Provisioner{

4
go.mod
View File

@ -17,6 +17,7 @@ require (
github.com/armon/go-radix v1.0.0 // indirect
github.com/aws/aws-sdk-go v1.16.24
github.com/biogo/hts v0.0.0-20160420073057-50da7d4131a3
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae
github.com/cheggaaa/pb v1.0.27
github.com/creack/goselect v0.0.0-20180210034346-528c74964609 // indirect
github.com/denverdino/aliyungo v0.0.0-20190220033614-36e2ae938978
@ -104,6 +105,8 @@ require (
github.com/ulikunitz/xz v0.5.5
github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311
github.com/xanzy/go-cloudstack v2.4.1+incompatible
github.com/yandex-cloud/go-genproto v0.0.0-20190401174212-1db0ef3dce9b
github.com/yandex-cloud/go-sdk v0.0.0-20190402114215-3fc1d6947035
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890
@ -111,6 +114,7 @@ require (
golang.org/x/sys v0.0.0-20181218192612-074acd46bca6
google.golang.org/api v0.1.0
google.golang.org/appengine v1.4.0 // indirect
google.golang.org/grpc v1.17.0
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
gopkg.in/h2non/gock.v1 v1.0.12 // indirect
gopkg.in/jarcoal/httpmock.v1 v1.0.0-20181117152235-275e9df93516 // indirect

26
go.sum
View File

@ -45,11 +45,16 @@ github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3A
github.com/aws/aws-sdk-go v1.16.24 h1:I/A3Hwbgs3IEAP6v1bFpHKXiT7wZDoToX9cb00nxZnM=
github.com/aws/aws-sdk-go v1.16.24/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/biogo/hts v0.0.0-20160420073057-50da7d4131a3 h1:3b+p838vN4sc37brz9W2HDphtSwZFcXZwFLyzm5Vk28=
github.com/biogo/hts v0.0.0-20160420073057-50da7d4131a3/go.mod h1:YOY5xnRf7Jz2SZCLSKgVfyqNzbRgyTznM3HyDqQMxcU=
github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae h1:2Zmk+8cNvAGuY8AyvZuWpUdpQUAXwfom4ReVMe/CTIo=
github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae/go.mod h1:S/7n9copUssQ56c7aAgHqftWO4LTf4xY6CGWt8Bc+3M=
github.com/cheggaaa/pb v1.0.27 h1:wIkZHkNfC7R6GI5w7l/PdAdzXzlrbcI3p8OAlnkTsnc=
github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
@ -79,6 +84,7 @@ github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
github.com/go-ini/ini v1.25.4 h1:Mujh4R/dH6YL8bxuISne3xX2+qcQ9p0IxKAP6ExWoUo=
@ -97,14 +103,17 @@ github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pO
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c h1:964Od4U6p2jUkFxvCydnIczKteheJEzHRToSGK3Bnlw=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/shlex v0.0.0-20150127133951-6f45313302b9 h1:JM174NTeGNJ2m/oLH3UOWOvWQQKd+BoL3hcSCUWFLt0=
github.com/google/shlex v0.0.0-20150127133951-6f45313302b9/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/googleapis/gax-go v2.0.0+incompatible h1:j0GKcs05QVmm7yesiZq2+9cxHkNK9YM6zKx4D2qucQU=
github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
@ -123,9 +132,11 @@ github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:Fecb
github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
github.com/hashicorp/consul v1.4.0 h1:PQTW4xCuAExEiSbhrsFsikzbW5gVBoi74BjUvYFyKHw=
github.com/hashicorp/consul v1.4.0/go.mod h1:mFrjN1mfidgJfYP1xrJCF+AfRhr6Eaqhb2+sfyn/OOI=
github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de h1:XDCSythtg8aWSRSO29uwhgh7b127fWr+m5SemqjSUL8=
github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de/go.mod h1:xIwEieBHERyEvaeKF/TcHh1Hu+lxPM+n2vT1+g9I4m4=
github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-getter v1.2.0 h1:E05bVPilzyh2yXgT6srn7WEkfMZaH+LuX9tDJw/4kaE=
github.com/hashicorp/go-getter v1.2.0/go.mod h1:/O1k/AizTN0QmfEKknCYGvICeyKUDqCYA8vvWtGWDeQ=
@ -133,6 +144,7 @@ github.com/hashicorp/go-immutable-radix v1.0.0 h1:AKDB1HM5PWEA7i4nhcpwOrO2byshxB
github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-msgpack v0.5.3 h1:zKjpN5BK/P5lMYrLmBHdBULWbJ0XpYR+7NGzqkZzoD4=
github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79 h1:RKu7yAXZTaQsxj1K9GDsh+QVw0+Wu1SWHxtbFN0n+hE=
github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79/go.mod h1:09jT3Y/OIsjTjQ2+3bkVNPDKqWcGIYYvjB2BEKVUdvc=
@ -140,6 +152,7 @@ github.com/hashicorp/go-retryablehttp v0.5.2 h1:AoISa4P4IsW0/m4T6St8Yw38gTl5GtBA
github.com/hashicorp/go-retryablehttp v0.5.2/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90 h1:VBj0QYQ0u2MCJzBfeYXGexnAl17GsH1yidnoxCqqD9E=
github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90/go.mod h1:o4zcYY1e0GEZI6eSEr+43QDYmuGglw1qSO6qdHUHCgg=
github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
github.com/hashicorp/go-sockaddr v1.0.0 h1:GeH6tui99pF4NJgfnhp+L6+FfobzVW3Ah46sLo0ICXs=
github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
@ -147,10 +160,12 @@ github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdv
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE=
github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-version v1.1.0 h1:bPIoEKD27tNdebFGGxxYwcL4nepeY4j1QP23PFRGzg0=
github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
@ -210,7 +225,9 @@ github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939/go.mod h1:CfZSN7zw
github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
github.com/mattn/go-tty v0.0.0-20190407112021-83fae09cc007 h1:xjZxmVDmDZoEsl2gV0qD0pyBH+wXmJIZd27wsNFphJk=
github.com/mattn/go-tty v0.0.0-20190407112021-83fae09cc007/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
@ -219,9 +236,11 @@ github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00v
github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
github.com/miekg/dns v1.1.1 h1:DVkblRdiScEnEr0LR9nTnEQqHYycjkXW9bOjd+2EL2o=
github.com/miekg/dns v1.1.1/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
github.com/mitchellh/cli v1.0.0 h1:iGBIsUe3+HZ/AD/Vd7DErOt5sU9fa8Uj7A2s1aggv1Y=
github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7 h1:PXPMDtfqV+rZJshQHOiwUFqlqErXaAcuWy+/ZmyRfNc=
github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7/go.mod h1:g7SZj7ABpStq3tM4zqHiVEG5un/DZ1+qJJKO7qx1EvU=
github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-testing-interface v1.0.0 h1:fzU/JVNcaqHQEcVFAKeR41fkiLdIPrefOvVG1VZ96U0=
github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
@ -262,7 +281,9 @@ github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a h1:A3QMut
github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a/go.mod h1:f6Izs6JvFTdnRbziASagjZ2vmf55NSIkC/weStxCHqk=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c h1:Lgl0gzECD8GnQ5QCWA8o6BtfL6mDH5rQgM4/fX3avOs=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/sftp v0.0.0-20160118190721-e84cc8c755ca h1:k8gsErq3rkcbAyCnpOycQsbw88NjCHk7L3KfBZKhQDQ=
github.com/pkg/sftp v0.0.0-20160118190721-e84cc8c755ca/go.mod h1:NxmoDg/QLVWluQDUYG7XBZTLUpKeFa8e3aMf1BfjyHk=
@ -284,6 +305,7 @@ github.com/rwtodd/Go.Sed v0.0.0-20170507045331-d6d5d585814e/go.mod h1:8AEUvGVi2u
github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735 h1:7YvPJVmEeFHR1Tj9sZEYsmarJEQfMVYpd/Vyy/A8dqE=
github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=
github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70 h1:DaqC32ZwOuO4ctgg9qAdKnlQxwFPkKmCOEqwSNwYy7c=
github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70/go.mod h1:XjlXWPd6VONhsRSEuzGkV8mzRpH7ou1cdLV7IKJk96s=
@ -338,6 +360,10 @@ github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311 h1:s5pyxd5S6wRs2WpE
github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311/go.mod h1:URlwyTFZX72RmxtxuaFL2Uj3fD1JTvZdx59bHWk6aFU=
github.com/xanzy/go-cloudstack v2.4.1+incompatible h1:Oc4xa2+I94h1g/QJ+nHoq597nJz2KXzxuQx/weOx0AU=
github.com/xanzy/go-cloudstack v2.4.1+incompatible/go.mod h1:s3eL3z5pNXF5FVybcT+LIVdId8pYn709yv6v5mrkrQE=
github.com/yandex-cloud/go-genproto v0.0.0-20190401174212-1db0ef3dce9b h1:WcWw17zHjM1QoM5dPD2XUK9S0wSKlyohlCMeb1rwr0g=
github.com/yandex-cloud/go-genproto v0.0.0-20190401174212-1db0ef3dce9b/go.mod h1:HEUYX/p8966tMUHHT+TsS0hF/Ca/NYwqprC5WXSDMfE=
github.com/yandex-cloud/go-sdk v0.0.0-20190402114215-3fc1d6947035 h1:2ZLZeg6xp+kYYGR2iMWSZyTn6j8bphNguO3drw7S1l4=
github.com/yandex-cloud/go-sdk v0.0.0-20190402114215-3fc1d6947035/go.mod h1:Eml0jFLU4VVHgIN8zPHMuNwZXVzUMILyO6lQZSfz854=
go.opencensus.io v0.18.0 h1:Mk5rgZcggtbvtAun5aJzAtjKKN/t0R3jJPlWILlv938=
go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=

24
vendor/github.com/c2h5oh/datasize/.gitignore generated vendored Normal file
View File

@ -0,0 +1,24 @@
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof

11
vendor/github.com/c2h5oh/datasize/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,11 @@
sudo: false
language: go
go:
- 1.4
- 1.5
- 1.6
- tip
script:
- go test -v

21
vendor/github.com/c2h5oh/datasize/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2016 Maciej Lisiewski
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

66
vendor/github.com/c2h5oh/datasize/README.md generated vendored Normal file
View File

@ -0,0 +1,66 @@
# datasize [![Build Status](https://travis-ci.org/c2h5oh/datasize.svg?branch=master)](https://travis-ci.org/c2h5oh/datasize)
Golang helpers for data sizes
### Constants
Just like `time` package provides `time.Second`, `time.Day` constants `datasize` provides:
* `datasize.B` 1 byte
* `datasize.KB` 1 kilobyte
* `datasize.MB` 1 megabyte
* `datasize.GB` 1 gigabyte
* `datasize.TB` 1 terabyte
* `datasize.PB` 1 petabyte
* `datasize.EB` 1 exabyte
### Helpers
Just like `time` package provides `duration.Nanoseconds() uint64 `, `duration.Hours() float64` helpers `datasize` has
* `ByteSize.Bytes() uint64`
* `ByteSize.Kilobytes() float4`
* `ByteSize.Megabytes() float64`
* `ByteSize.Gigabytes() float64`
* `ByteSize.Terabytes() float64`
* `ByteSize.Petebytes() float64`
* `ByteSize.Exabytes() float64`
Warning: see limitations at the end of this document about a possible precission loss
### Parsing strings
`datasize.ByteSize` implements `TextUnmarshaler` interface and will automatically parse human readable strings into correct values where it is used:
* `"10 MB"` -> `10* datasize.MB`
* `"10240 g"` -> `10 * datasize.TB`
* `"2000"` -> `2000 * datasize.B`
* `"1tB"` -> `datasize.TB`
* `"5 peta"` -> `5 * datasize.PB`
* `"28 kilobytes"` -> `28 * datasize.KB`
* `"1 gigabyte"` -> `1 * datasize.GB`
You can also do it manually:
```go
var v datasize.ByteSize
err := v.UnmarshalText([]byte("100 mb"))
```
### Printing
`Bytesize.String()` uses largest unit allowing an integer value:
* `(102400 * datasize.MB).String()` -> `"100GB"`
* `(datasize.MB + datasize.KB).String()` -> `"1025KB"`
Use `%d` format string to get value in bytes without a unit
### JSON and other encoding
Both `TextMarshaler` and `TextUnmarshaler` interfaces are implemented - JSON will just work. Other encoders will work provided they use those interfaces.
### Human readable
`ByteSize.HumanReadable()` or `ByteSize.HR()` returns a string with 1-3 digits, followed by 1 decimal place, a space and unit big enough to get 1-3 digits
* `(102400 * datasize.MB).String()` -> `"100.0 GB"`
* `(datasize.MB + 512 * datasize.KB).String()` -> `"1.5 MB"`
### Limitations
* The underlying data type for `data.ByteSize` is `uint64`, so values outside of 0 to 2^64-1 range will overflow
* size helper functions (like `ByteSize.Kilobytes()`) return `float64`, which can't represent all possible values of `uint64` accurately:
* if the returned value is supposed to have no fraction (ie `(10 * datasize.MB).Kilobytes()`) accuracy loss happens when value is more than 2^53 larger than unit: `.Kilobytes()` over 8 petabytes, `.Megabytes()` over 8 exabytes
* if the returned value is supposed to have a fraction (ie `(datasize.PB + datasize.B).Megabytes()`) in addition to the above note accuracy loss may occur in fractional part too - larger integer part leaves fewer bytes to store fractional part, the smaller the remainder vs unit the move bytes are required to store the fractional part
* Parsing a string with `Mb`, `Tb`, etc units will return a syntax error, because capital followed by lower case is commonly used for bits, not bytes
* Parsing a string with value exceeding 2^64-1 bytes will return 2^64-1 and an out of range error

217
vendor/github.com/c2h5oh/datasize/datasize.go generated vendored Normal file
View File

@ -0,0 +1,217 @@
package datasize
import (
"errors"
"fmt"
"strconv"
"strings"
)
type ByteSize uint64
const (
B ByteSize = 1
KB = B << 10
MB = KB << 10
GB = MB << 10
TB = GB << 10
PB = TB << 10
EB = PB << 10
fnUnmarshalText string = "UnmarshalText"
maxUint64 uint64 = (1 << 64) - 1
cutoff uint64 = maxUint64 / 10
)
var ErrBits = errors.New("unit with capital unit prefix and lower case unit (b) - bits, not bytes ")
func (b ByteSize) Bytes() uint64 {
return uint64(b)
}
func (b ByteSize) KBytes() float64 {
v := b / KB
r := b % KB
return float64(v) + float64(r)/float64(KB)
}
func (b ByteSize) MBytes() float64 {
v := b / MB
r := b % MB
return float64(v) + float64(r)/float64(MB)
}
func (b ByteSize) GBytes() float64 {
v := b / GB
r := b % GB
return float64(v) + float64(r)/float64(GB)
}
func (b ByteSize) TBytes() float64 {
v := b / TB
r := b % TB
return float64(v) + float64(r)/float64(TB)
}
func (b ByteSize) PBytes() float64 {
v := b / PB
r := b % PB
return float64(v) + float64(r)/float64(PB)
}
func (b ByteSize) EBytes() float64 {
v := b / EB
r := b % EB
return float64(v) + float64(r)/float64(EB)
}
func (b ByteSize) String() string {
switch {
case b == 0:
return fmt.Sprint("0B")
case b%EB == 0:
return fmt.Sprintf("%dEB", b/EB)
case b%PB == 0:
return fmt.Sprintf("%dPB", b/PB)
case b%TB == 0:
return fmt.Sprintf("%dTB", b/TB)
case b%GB == 0:
return fmt.Sprintf("%dGB", b/GB)
case b%MB == 0:
return fmt.Sprintf("%dMB", b/MB)
case b%KB == 0:
return fmt.Sprintf("%dKB", b/KB)
default:
return fmt.Sprintf("%dB", b)
}
}
func (b ByteSize) HR() string {
return b.HumanReadable()
}
func (b ByteSize) HumanReadable() string {
switch {
case b > EB:
return fmt.Sprintf("%.1f EB", b.EBytes())
case b > PB:
return fmt.Sprintf("%.1f PB", b.PBytes())
case b > TB:
return fmt.Sprintf("%.1f TB", b.TBytes())
case b > GB:
return fmt.Sprintf("%.1f GB", b.GBytes())
case b > MB:
return fmt.Sprintf("%.1f MB", b.MBytes())
case b > KB:
return fmt.Sprintf("%.1f KB", b.KBytes())
default:
return fmt.Sprintf("%d B", b)
}
}
func (b ByteSize) MarshalText() ([]byte, error) {
return []byte(b.String()), nil
}
func (b *ByteSize) UnmarshalText(t []byte) error {
var val uint64
var unit string
// copy for error message
t0 := t
var c byte
var i int
ParseLoop:
for i < len(t) {
c = t[i]
switch {
case '0' <= c && c <= '9':
if val > cutoff {
goto Overflow
}
c = c - '0'
val *= 10
if val > val+uint64(c) {
// val+v overflows
goto Overflow
}
val += uint64(c)
i++
default:
if i == 0 {
goto SyntaxError
}
break ParseLoop
}
}
unit = strings.TrimSpace(string(t[i:]))
switch unit {
case "Kb", "Mb", "Gb", "Tb", "Pb", "Eb":
goto BitsError
}
unit = strings.ToLower(unit)
switch unit {
case "", "b", "byte":
// do nothing - already in bytes
case "k", "kb", "kilo", "kilobyte", "kilobytes":
if val > maxUint64/uint64(KB) {
goto Overflow
}
val *= uint64(KB)
case "m", "mb", "mega", "megabyte", "megabytes":
if val > maxUint64/uint64(MB) {
goto Overflow
}
val *= uint64(MB)
case "g", "gb", "giga", "gigabyte", "gigabytes":
if val > maxUint64/uint64(GB) {
goto Overflow
}
val *= uint64(GB)
case "t", "tb", "tera", "terabyte", "terabytes":
if val > maxUint64/uint64(TB) {
goto Overflow
}
val *= uint64(TB)
case "p", "pb", "peta", "petabyte", "petabytes":
if val > maxUint64/uint64(PB) {
goto Overflow
}
val *= uint64(PB)
case "E", "EB", "e", "eb", "eB":
if val > maxUint64/uint64(EB) {
goto Overflow
}
val *= uint64(EB)
default:
goto SyntaxError
}
*b = ByteSize(val)
return nil
Overflow:
*b = ByteSize(maxUint64)
return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrRange}
SyntaxError:
*b = 0
return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrSyntax}
BitsError:
*b = 0
return &strconv.NumError{fnUnmarshalText, string(t0), ErrBits}
}

20
vendor/github.com/ghodss/yaml/.gitignore generated vendored Normal file
View File

@ -0,0 +1,20 @@
# OSX leaves these everywhere on SMB shares
._*
# Eclipse files
.classpath
.project
.settings/**
# Emacs save files
*~
# Vim-related files
[._]*.s[a-w][a-z]
[._]s[a-w][a-z]
*.un~
Session.vim
.netrwhist
# Go test binaries
*.test

7
vendor/github.com/ghodss/yaml/.travis.yml generated vendored Normal file
View File

@ -0,0 +1,7 @@
language: go
go:
- 1.3
- 1.4
script:
- go test
- go build

50
vendor/github.com/ghodss/yaml/LICENSE generated vendored Normal file
View File

@ -0,0 +1,50 @@
The MIT License (MIT)
Copyright (c) 2014 Sam Ghods
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copyright (c) 2012 The Go Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

121
vendor/github.com/ghodss/yaml/README.md generated vendored Normal file
View File

@ -0,0 +1,121 @@
# YAML marshaling and unmarshaling support for Go
[![Build Status](https://travis-ci.org/ghodss/yaml.svg)](https://travis-ci.org/ghodss/yaml)
## Introduction
A wrapper around [go-yaml](https://github.com/go-yaml/yaml) designed to enable a better way of handling YAML when marshaling to and from structs.
In short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).
## Compatibility
This package uses [go-yaml](https://github.com/go-yaml/yaml) and therefore supports [everything go-yaml supports](https://github.com/go-yaml/yaml#compatibility).
## Caveats
**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
```
BAD:
exampleKey: !!binary gIGC
GOOD:
exampleKey: gIGC
... and decode the base64 data in your code.
```
**Caveat #2:** When using `YAMLToJSON` directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in `Unmarshal` as well since you can't unmarshal map keys anyways since struct fields can't be keys.
## Installation and usage
To install, run:
```
$ go get github.com/ghodss/yaml
```
And import using:
```
import "github.com/ghodss/yaml"
```
Usage is very similar to the JSON library:
```go
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
type Person struct {
Name string `json:"name"` // Affects YAML field names too.
Age int `json:"age"`
}
func main() {
// Marshal a Person struct to YAML.
p := Person{"John", 30}
y, err := yaml.Marshal(p)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
age: 30
name: John
*/
// Unmarshal the YAML back into a Person struct.
var p2 Person
err = yaml.Unmarshal(y, &p2)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(p2)
/* Output:
{John 30}
*/
}
```
`yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available:
```go
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
func main() {
j := []byte(`{"name": "John", "age": 30}`)
y, err := yaml.JSONToYAML(j)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
name: John
age: 30
*/
j2, err := yaml.YAMLToJSON(y)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(j2))
/* Output:
{"age":30,"name":"John"}
*/
}
```

501
vendor/github.com/ghodss/yaml/fields.go generated vendored Normal file
View File

@ -0,0 +1,501 @@
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package yaml
import (
"bytes"
"encoding"
"encoding/json"
"reflect"
"sort"
"strings"
"sync"
"unicode"
"unicode/utf8"
)
// indirect walks down v allocating pointers as needed,
// until it gets to a non-pointer.
// if it encounters an Unmarshaler, indirect stops and returns that.
// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
// If v is a named type and is addressable,
// start with its address, so that if the type has pointer methods,
// we find them.
if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
v = v.Addr()
}
for {
// Load value from interface, but only if the result will be
// usefully addressable.
if v.Kind() == reflect.Interface && !v.IsNil() {
e := v.Elem()
if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
v = e
continue
}
}
if v.Kind() != reflect.Ptr {
break
}
if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
break
}
if v.IsNil() {
if v.CanSet() {
v.Set(reflect.New(v.Type().Elem()))
} else {
v = reflect.New(v.Type().Elem())
}
}
if v.Type().NumMethod() > 0 {
if u, ok := v.Interface().(json.Unmarshaler); ok {
return u, nil, reflect.Value{}
}
if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
return nil, u, reflect.Value{}
}
}
v = v.Elem()
}
return nil, nil, v
}
// A field represents a single field found in a struct.
type field struct {
name string
nameBytes []byte // []byte(name)
equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent
tag bool
index []int
typ reflect.Type
omitEmpty bool
quoted bool
}
func fillField(f field) field {
f.nameBytes = []byte(f.name)
f.equalFold = foldFunc(f.nameBytes)
return f
}
// byName sorts field by name, breaking ties with depth,
// then breaking ties with "name came from json tag", then
// breaking ties with index sequence.
type byName []field
func (x byName) Len() int { return len(x) }
func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byName) Less(i, j int) bool {
if x[i].name != x[j].name {
return x[i].name < x[j].name
}
if len(x[i].index) != len(x[j].index) {
return len(x[i].index) < len(x[j].index)
}
if x[i].tag != x[j].tag {
return x[i].tag
}
return byIndex(x).Less(i, j)
}
// byIndex sorts field by index sequence.
type byIndex []field
func (x byIndex) Len() int { return len(x) }
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byIndex) Less(i, j int) bool {
for k, xik := range x[i].index {
if k >= len(x[j].index) {
return false
}
if xik != x[j].index[k] {
return xik < x[j].index[k]
}
}
return len(x[i].index) < len(x[j].index)
}
// typeFields returns a list of fields that JSON should recognize for the given type.
// The algorithm is breadth-first search over the set of structs to include - the top struct
// and then any reachable anonymous structs.
func typeFields(t reflect.Type) []field {
// Anonymous fields to explore at the current level and the next.
current := []field{}
next := []field{{typ: t}}
// Count of queued names for current level and the next.
count := map[reflect.Type]int{}
nextCount := map[reflect.Type]int{}
// Types already visited at an earlier level.
visited := map[reflect.Type]bool{}
// Fields found.
var fields []field
for len(next) > 0 {
current, next = next, current[:0]
count, nextCount = nextCount, map[reflect.Type]int{}
for _, f := range current {
if visited[f.typ] {
continue
}
visited[f.typ] = true
// Scan f.typ for fields to include.
for i := 0; i < f.typ.NumField(); i++ {
sf := f.typ.Field(i)
if sf.PkgPath != "" { // unexported
continue
}
tag := sf.Tag.Get("json")
if tag == "-" {
continue
}
name, opts := parseTag(tag)
if !isValidTag(name) {
name = ""
}
index := make([]int, len(f.index)+1)
copy(index, f.index)
index[len(f.index)] = i
ft := sf.Type
if ft.Name() == "" && ft.Kind() == reflect.Ptr {
// Follow pointer.
ft = ft.Elem()
}
// Record found field and index sequence.
if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
tagged := name != ""
if name == "" {
name = sf.Name
}
fields = append(fields, fillField(field{
name: name,
tag: tagged,
index: index,
typ: ft,
omitEmpty: opts.Contains("omitempty"),
quoted: opts.Contains("string"),
}))
if count[f.typ] > 1 {
// If there were multiple instances, add a second,
// so that the annihilation code will see a duplicate.
// It only cares about the distinction between 1 or 2,
// so don't bother generating any more copies.
fields = append(fields, fields[len(fields)-1])
}
continue
}
// Record new anonymous struct to explore in next round.
nextCount[ft]++
if nextCount[ft] == 1 {
next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
}
}
}
}
sort.Sort(byName(fields))
// Delete all fields that are hidden by the Go rules for embedded fields,
// except that fields with JSON tags are promoted.
// The fields are sorted in primary order of name, secondary order
// of field index length. Loop over names; for each name, delete
// hidden fields by choosing the one dominant field that survives.
out := fields[:0]
for advance, i := 0, 0; i < len(fields); i += advance {
// One iteration per name.
// Find the sequence of fields with the name of this first field.
fi := fields[i]
name := fi.name
for advance = 1; i+advance < len(fields); advance++ {
fj := fields[i+advance]
if fj.name != name {
break
}
}
if advance == 1 { // Only one field with this name
out = append(out, fi)
continue
}
dominant, ok := dominantField(fields[i : i+advance])
if ok {
out = append(out, dominant)
}
}
fields = out
sort.Sort(byIndex(fields))
return fields
}
// dominantField looks through the fields, all of which are known to
// have the same name, to find the single field that dominates the
// others using Go's embedding rules, modified by the presence of
// JSON tags. If there are multiple top-level fields, the boolean
// will be false: This condition is an error in Go and we skip all
// the fields.
func dominantField(fields []field) (field, bool) {
// The fields are sorted in increasing index-length order. The winner
// must therefore be one with the shortest index length. Drop all
// longer entries, which is easy: just truncate the slice.
length := len(fields[0].index)
tagged := -1 // Index of first tagged field.
for i, f := range fields {
if len(f.index) > length {
fields = fields[:i]
break
}
if f.tag {
if tagged >= 0 {
// Multiple tagged fields at the same level: conflict.
// Return no field.
return field{}, false
}
tagged = i
}
}
if tagged >= 0 {
return fields[tagged], true
}
// All remaining fields have the same length. If there's more than one,
// we have a conflict (two fields named "X" at the same level) and we
// return no field.
if len(fields) > 1 {
return field{}, false
}
return fields[0], true
}
var fieldCache struct {
sync.RWMutex
m map[reflect.Type][]field
}
// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
func cachedTypeFields(t reflect.Type) []field {
fieldCache.RLock()
f := fieldCache.m[t]
fieldCache.RUnlock()
if f != nil {
return f
}
// Compute fields without lock.
// Might duplicate effort but won't hold other computations back.
f = typeFields(t)
if f == nil {
f = []field{}
}
fieldCache.Lock()
if fieldCache.m == nil {
fieldCache.m = map[reflect.Type][]field{}
}
fieldCache.m[t] = f
fieldCache.Unlock()
return f
}
func isValidTag(s string) bool {
if s == "" {
return false
}
for _, c := range s {
switch {
case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
// Backslash and quote chars are reserved, but
// otherwise any punctuation chars are allowed
// in a tag name.
default:
if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
return false
}
}
}
return true
}
const (
caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
kelvin = '\u212a'
smallLongEss = '\u017f'
)
// foldFunc returns one of four different case folding equivalence
// functions, from most general (and slow) to fastest:
//
// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
// 3) asciiEqualFold, no special, but includes non-letters (including _)
// 4) simpleLetterEqualFold, no specials, no non-letters.
//
// The letters S and K are special because they map to 3 runes, not just 2:
// * S maps to s and to U+017F 'ſ' Latin small letter long s
// * k maps to K and to U+212A 'K' Kelvin sign
// See http://play.golang.org/p/tTxjOc0OGo
//
// The returned function is specialized for matching against s and
// should only be given s. It's not curried for performance reasons.
func foldFunc(s []byte) func(s, t []byte) bool {
nonLetter := false
special := false // special letter
for _, b := range s {
if b >= utf8.RuneSelf {
return bytes.EqualFold
}
upper := b & caseMask
if upper < 'A' || upper > 'Z' {
nonLetter = true
} else if upper == 'K' || upper == 'S' {
// See above for why these letters are special.
special = true
}
}
if special {
return equalFoldRight
}
if nonLetter {
return asciiEqualFold
}
return simpleLetterEqualFold
}
// equalFoldRight is a specialization of bytes.EqualFold when s is
// known to be all ASCII (including punctuation), but contains an 's',
// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
// See comments on foldFunc.
func equalFoldRight(s, t []byte) bool {
for _, sb := range s {
if len(t) == 0 {
return false
}
tb := t[0]
if tb < utf8.RuneSelf {
if sb != tb {
sbUpper := sb & caseMask
if 'A' <= sbUpper && sbUpper <= 'Z' {
if sbUpper != tb&caseMask {
return false
}
} else {
return false
}
}
t = t[1:]
continue
}
// sb is ASCII and t is not. t must be either kelvin
// sign or long s; sb must be s, S, k, or K.
tr, size := utf8.DecodeRune(t)
switch sb {
case 's', 'S':
if tr != smallLongEss {
return false
}
case 'k', 'K':
if tr != kelvin {
return false
}
default:
return false
}
t = t[size:]
}
if len(t) > 0 {
return false
}
return true
}
// asciiEqualFold is a specialization of bytes.EqualFold for use when
// s is all ASCII (but may contain non-letters) and contains no
// special-folding letters.
// See comments on foldFunc.
func asciiEqualFold(s, t []byte) bool {
if len(s) != len(t) {
return false
}
for i, sb := range s {
tb := t[i]
if sb == tb {
continue
}
if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
if sb&caseMask != tb&caseMask {
return false
}
} else {
return false
}
}
return true
}
// simpleLetterEqualFold is a specialization of bytes.EqualFold for
// use when s is all ASCII letters (no underscores, etc) and also
// doesn't contain 'k', 'K', 's', or 'S'.
// See comments on foldFunc.
func simpleLetterEqualFold(s, t []byte) bool {
if len(s) != len(t) {
return false
}
for i, b := range s {
if b&caseMask != t[i]&caseMask {
return false
}
}
return true
}
// tagOptions is the string following a comma in a struct field's "json"
// tag, or the empty string. It does not include the leading comma.
type tagOptions string
// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func parseTag(tag string) (string, tagOptions) {
if idx := strings.Index(tag, ","); idx != -1 {
return tag[:idx], tagOptions(tag[idx+1:])
}
return tag, tagOptions("")
}
// Contains reports whether a comma-separated list of options
// contains a particular substr flag. substr must be surrounded by a
// string boundary or commas.
func (o tagOptions) Contains(optionName string) bool {
if len(o) == 0 {
return false
}
s := string(o)
for s != "" {
var next string
i := strings.Index(s, ",")
if i >= 0 {
s, next = s[:i], s[i+1:]
}
if s == optionName {
return true
}
s = next
}
return false
}

277
vendor/github.com/ghodss/yaml/yaml.go generated vendored Normal file
View File

@ -0,0 +1,277 @@
package yaml
import (
"bytes"
"encoding/json"
"fmt"
"reflect"
"strconv"
"gopkg.in/yaml.v2"
)
// Marshals the object into JSON then converts JSON to YAML and returns the
// YAML.
func Marshal(o interface{}) ([]byte, error) {
j, err := json.Marshal(o)
if err != nil {
return nil, fmt.Errorf("error marshaling into JSON: %v", err)
}
y, err := JSONToYAML(j)
if err != nil {
return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
}
return y, nil
}
// Converts YAML to JSON then uses JSON to unmarshal into an object.
func Unmarshal(y []byte, o interface{}) error {
vo := reflect.ValueOf(o)
j, err := yamlToJSON(y, &vo)
if err != nil {
return fmt.Errorf("error converting YAML to JSON: %v", err)
}
err = json.Unmarshal(j, o)
if err != nil {
return fmt.Errorf("error unmarshaling JSON: %v", err)
}
return nil
}
// Convert JSON to YAML.
func JSONToYAML(j []byte) ([]byte, error) {
// Convert the JSON to an object.
var jsonObj interface{}
// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
// Go JSON library doesn't try to pick the right number type (int, float,
// etc.) when unmarshalling to interface{}, it just picks float64
// universally. go-yaml does go through the effort of picking the right
// number type, so we can preserve number type throughout this process.
err := yaml.Unmarshal(j, &jsonObj)
if err != nil {
return nil, err
}
// Marshal this object into YAML.
return yaml.Marshal(jsonObj)
}
// Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through
// this method should be a no-op.
//
// Things YAML can do that are not supported by JSON:
// * In YAML you can have binary and null keys in your maps. These are invalid
// in JSON. (int and float keys are converted to strings.)
// * Binary data in YAML with the !!binary tag is not supported. If you want to
// use binary data with this library, encode the data as base64 as usual but do
// not use the !!binary tag in your YAML. This will ensure the original base64
// encoded data makes it all the way through to the JSON.
func YAMLToJSON(y []byte) ([]byte, error) {
return yamlToJSON(y, nil)
}
func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) {
// Convert the YAML to an object.
var yamlObj interface{}
err := yaml.Unmarshal(y, &yamlObj)
if err != nil {
return nil, err
}
// YAML objects are not completely compatible with JSON objects (e.g. you
// can have non-string keys in YAML). So, convert the YAML-compatible object
// to a JSON-compatible object, failing with an error if irrecoverable
// incompatibilties happen along the way.
jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget)
if err != nil {
return nil, err
}
// Convert this object to JSON and return the data.
return json.Marshal(jsonObj)
}
func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {
var err error
// Resolve jsonTarget to a concrete value (i.e. not a pointer or an
// interface). We pass decodingNull as false because we're not actually
// decoding into the value, we're just checking if the ultimate target is a
// string.
if jsonTarget != nil {
ju, tu, pv := indirect(*jsonTarget, false)
// We have a JSON or Text Umarshaler at this level, so we can't be trying
// to decode into a string.
if ju != nil || tu != nil {
jsonTarget = nil
} else {
jsonTarget = &pv
}
}
// If yamlObj is a number or a boolean, check if jsonTarget is a string -
// if so, coerce. Else return normal.
// If yamlObj is a map or array, find the field that each key is
// unmarshaling to, and when you recurse pass the reflect.Value for that
// field back into this function.
switch typedYAMLObj := yamlObj.(type) {
case map[interface{}]interface{}:
// JSON does not support arbitrary keys in a map, so we must convert
// these keys to strings.
//
// From my reading of go-yaml v2 (specifically the resolve function),
// keys can only have the types string, int, int64, float64, binary
// (unsupported), or null (unsupported).
strMap := make(map[string]interface{})
for k, v := range typedYAMLObj {
// Resolve the key to a string first.
var keyString string
switch typedKey := k.(type) {
case string:
keyString = typedKey
case int:
keyString = strconv.Itoa(typedKey)
case int64:
// go-yaml will only return an int64 as a key if the system
// architecture is 32-bit and the key's value is between 32-bit
// and 64-bit. Otherwise the key type will simply be int.
keyString = strconv.FormatInt(typedKey, 10)
case float64:
// Stolen from go-yaml to use the same conversion to string as
// the go-yaml library uses to convert float to string when
// Marshaling.
s := strconv.FormatFloat(typedKey, 'g', -1, 32)
switch s {
case "+Inf":
s = ".inf"
case "-Inf":
s = "-.inf"
case "NaN":
s = ".nan"
}
keyString = s
case bool:
if typedKey {
keyString = "true"
} else {
keyString = "false"
}
default:
return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",
reflect.TypeOf(k), k, v)
}
// jsonTarget should be a struct or a map. If it's a struct, find
// the field it's going to map to and pass its reflect.Value. If
// it's a map, find the element type of the map and pass the
// reflect.Value created from that type. If it's neither, just pass
// nil - JSON conversion will error for us if it's a real issue.
if jsonTarget != nil {
t := *jsonTarget
if t.Kind() == reflect.Struct {
keyBytes := []byte(keyString)
// Find the field that the JSON library would use.
var f *field
fields := cachedTypeFields(t.Type())
for i := range fields {
ff := &fields[i]
if bytes.Equal(ff.nameBytes, keyBytes) {
f = ff
break
}
// Do case-insensitive comparison.
if f == nil && ff.equalFold(ff.nameBytes, keyBytes) {
f = ff
}
}
if f != nil {
// Find the reflect.Value of the most preferential
// struct field.
jtf := t.Field(f.index[0])
strMap[keyString], err = convertToJSONableObject(v, &jtf)
if err != nil {
return nil, err
}
continue
}
} else if t.Kind() == reflect.Map {
// Create a zero value of the map's element type to use as
// the JSON target.
jtv := reflect.Zero(t.Type().Elem())
strMap[keyString], err = convertToJSONableObject(v, &jtv)
if err != nil {
return nil, err
}
continue
}
}
strMap[keyString], err = convertToJSONableObject(v, nil)
if err != nil {
return nil, err
}
}
return strMap, nil
case []interface{}:
// We need to recurse into arrays in case there are any
// map[interface{}]interface{}'s inside and to convert any
// numbers to strings.
// If jsonTarget is a slice (which it really should be), find the
// thing it's going to map to. If it's not a slice, just pass nil
// - JSON conversion will error for us if it's a real issue.
var jsonSliceElemValue *reflect.Value
if jsonTarget != nil {
t := *jsonTarget
if t.Kind() == reflect.Slice {
// By default slices point to nil, but we need a reflect.Value
// pointing to a value of the slice type, so we create one here.
ev := reflect.Indirect(reflect.New(t.Type().Elem()))
jsonSliceElemValue = &ev
}
}
// Make and use a new array.
arr := make([]interface{}, len(typedYAMLObj))
for i, v := range typedYAMLObj {
arr[i], err = convertToJSONableObject(v, jsonSliceElemValue)
if err != nil {
return nil, err
}
}
return arr, nil
default:
// If the target type is a string and the YAML type is a number,
// convert the YAML type to a string.
if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {
// Based on my reading of go-yaml, it may return int, int64,
// float64, or uint64.
var s string
switch typedVal := typedYAMLObj.(type) {
case int:
s = strconv.FormatInt(int64(typedVal), 10)
case int64:
s = strconv.FormatInt(typedVal, 10)
case float64:
s = strconv.FormatFloat(typedVal, 'g', -1, 32)
case uint64:
s = strconv.FormatUint(typedVal, 10)
case bool:
if typedVal {
s = "true"
} else {
s = "false"
}
}
if len(s) > 0 {
yamlObj = interface{}(s)
}
}
return yamlObj, nil
}
return nil, nil
}

1271
vendor/github.com/golang/protobuf/jsonpb/jsonpb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

79
vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go generated vendored Normal file
View File

@ -0,0 +1,79 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/empty.proto
package empty // import "github.com/golang/protobuf/ptypes/empty"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
type Empty struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) {
return fileDescriptor_empty_39e6d6db0632e5b2, []int{0}
}
func (*Empty) XXX_WellKnownType() string { return "Empty" }
func (m *Empty) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (dst *Empty) XXX_Merge(src proto.Message) {
xxx_messageInfo_Empty.Merge(dst, src)
}
func (m *Empty) XXX_Size() int {
return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
xxx_messageInfo_Empty.DiscardUnknown(m)
}
var xxx_messageInfo_Empty proto.InternalMessageInfo
func init() {
proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
}
func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_empty_39e6d6db0632e5b2) }
var fileDescriptor_empty_39e6d6db0632e5b2 = []byte{
// 148 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
0xb7, 0x00, 0x00, 0x00,
}

52
vendor/github.com/golang/protobuf/ptypes/empty/empty.proto generated vendored Normal file
View File

@ -0,0 +1,52 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option go_package = "github.com/golang/protobuf/ptypes/empty";
option java_package = "com.google.protobuf";
option java_outer_classname = "EmptyProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
option cc_enable_arenas = true;
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
message Empty {}

450
vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go generated vendored Normal file
View File

@ -0,0 +1,450 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/struct.proto
package structpb // import "github.com/golang/protobuf/ptypes/struct"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
type NullValue int32
const (
// Null value.
NullValue_NULL_VALUE NullValue = 0
)
var NullValue_name = map[int32]string{
0: "NULL_VALUE",
}
var NullValue_value = map[string]int32{
"NULL_VALUE": 0,
}
func (x NullValue) String() string {
return proto.EnumName(NullValue_name, int32(x))
}
func (NullValue) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_struct_3a5a94e0c7801b27, []int{0}
}
func (NullValue) XXX_WellKnownType() string { return "NullValue" }
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
type Struct struct {
// Unordered map of dynamically typed values.
Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Struct) Reset() { *m = Struct{} }
func (m *Struct) String() string { return proto.CompactTextString(m) }
func (*Struct) ProtoMessage() {}
func (*Struct) Descriptor() ([]byte, []int) {
return fileDescriptor_struct_3a5a94e0c7801b27, []int{0}
}
func (*Struct) XXX_WellKnownType() string { return "Struct" }
func (m *Struct) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Struct.Unmarshal(m, b)
}
func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
}
func (dst *Struct) XXX_Merge(src proto.Message) {
xxx_messageInfo_Struct.Merge(dst, src)
}
func (m *Struct) XXX_Size() int {
return xxx_messageInfo_Struct.Size(m)
}
func (m *Struct) XXX_DiscardUnknown() {
xxx_messageInfo_Struct.DiscardUnknown(m)
}
var xxx_messageInfo_Struct proto.InternalMessageInfo
func (m *Struct) GetFields() map[string]*Value {
if m != nil {
return m.Fields
}
return nil
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
type Value struct {
// The kind of value.
//
// Types that are valid to be assigned to Kind:
// *Value_NullValue
// *Value_NumberValue
// *Value_StringValue
// *Value_BoolValue
// *Value_StructValue
// *Value_ListValue
Kind isValue_Kind `protobuf_oneof:"kind"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Value) Reset() { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage() {}
func (*Value) Descriptor() ([]byte, []int) {
return fileDescriptor_struct_3a5a94e0c7801b27, []int{1}
}
func (*Value) XXX_WellKnownType() string { return "Value" }
func (m *Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Value.Unmarshal(m, b)
}
func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Value.Marshal(b, m, deterministic)
}
func (dst *Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Value.Merge(dst, src)
}
func (m *Value) XXX_Size() int {
return xxx_messageInfo_Value.Size(m)
}
func (m *Value) XXX_DiscardUnknown() {
xxx_messageInfo_Value.DiscardUnknown(m)
}
var xxx_messageInfo_Value proto.InternalMessageInfo
type isValue_Kind interface {
isValue_Kind()
}
type Value_NullValue struct {
NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
}
type Value_NumberValue struct {
NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
}
type Value_StringValue struct {
StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type Value_BoolValue struct {
BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
}
type Value_StructValue struct {
StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
}
type Value_ListValue struct {
ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
}
func (*Value_NullValue) isValue_Kind() {}
func (*Value_NumberValue) isValue_Kind() {}
func (*Value_StringValue) isValue_Kind() {}
func (*Value_BoolValue) isValue_Kind() {}
func (*Value_StructValue) isValue_Kind() {}
func (*Value_ListValue) isValue_Kind() {}
func (m *Value) GetKind() isValue_Kind {
if m != nil {
return m.Kind
}
return nil
}
func (m *Value) GetNullValue() NullValue {
if x, ok := m.GetKind().(*Value_NullValue); ok {
return x.NullValue
}
return NullValue_NULL_VALUE
}
func (m *Value) GetNumberValue() float64 {
if x, ok := m.GetKind().(*Value_NumberValue); ok {
return x.NumberValue
}
return 0
}
func (m *Value) GetStringValue() string {
if x, ok := m.GetKind().(*Value_StringValue); ok {
return x.StringValue
}
return ""
}
func (m *Value) GetBoolValue() bool {
if x, ok := m.GetKind().(*Value_BoolValue); ok {
return x.BoolValue
}
return false
}
func (m *Value) GetStructValue() *Struct {
if x, ok := m.GetKind().(*Value_StructValue); ok {
return x.StructValue
}
return nil
}
func (m *Value) GetListValue() *ListValue {
if x, ok := m.GetKind().(*Value_ListValue); ok {
return x.ListValue
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
(*Value_NullValue)(nil),
(*Value_NumberValue)(nil),
(*Value_StringValue)(nil),
(*Value_BoolValue)(nil),
(*Value_StructValue)(nil),
(*Value_ListValue)(nil),
}
}
func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Value)
// kind
switch x := m.Kind.(type) {
case *Value_NullValue:
b.EncodeVarint(1<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.NullValue))
case *Value_NumberValue:
b.EncodeVarint(2<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.NumberValue))
case *Value_StringValue:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringValue)
case *Value_BoolValue:
t := uint64(0)
if x.BoolValue {
t = 1
}
b.EncodeVarint(4<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *Value_StructValue:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.StructValue); err != nil {
return err
}
case *Value_ListValue:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.ListValue); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Value.Kind has unexpected type %T", x)
}
return nil
}
func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Value)
switch tag {
case 1: // kind.null_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Kind = &Value_NullValue{NullValue(x)}
return true, err
case 2: // kind.number_value
if wire != proto.WireFixed64 {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeFixed64()
m.Kind = &Value_NumberValue{math.Float64frombits(x)}
return true, err
case 3: // kind.string_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Kind = &Value_StringValue{x}
return true, err
case 4: // kind.bool_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Kind = &Value_BoolValue{x != 0}
return true, err
case 5: // kind.struct_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Struct)
err := b.DecodeMessage(msg)
m.Kind = &Value_StructValue{msg}
return true, err
case 6: // kind.list_value
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(ListValue)
err := b.DecodeMessage(msg)
m.Kind = &Value_ListValue{msg}
return true, err
default:
return false, nil
}
}
func _Value_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Value)
// kind
switch x := m.Kind.(type) {
case *Value_NullValue:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(x.NullValue))
case *Value_NumberValue:
n += 1 // tag and wire
n += 8
case *Value_StringValue:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.StringValue)))
n += len(x.StringValue)
case *Value_BoolValue:
n += 1 // tag and wire
n += 1
case *Value_StructValue:
s := proto.Size(x.StructValue)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *Value_ListValue:
s := proto.Size(x.ListValue)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
type ListValue struct {
// Repeated field of dynamically typed values.
Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListValue) Reset() { *m = ListValue{} }
func (m *ListValue) String() string { return proto.CompactTextString(m) }
func (*ListValue) ProtoMessage() {}
func (*ListValue) Descriptor() ([]byte, []int) {
return fileDescriptor_struct_3a5a94e0c7801b27, []int{2}
}
func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
func (m *ListValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListValue.Unmarshal(m, b)
}
func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
}
func (dst *ListValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListValue.Merge(dst, src)
}
func (m *ListValue) XXX_Size() int {
return xxx_messageInfo_ListValue.Size(m)
}
func (m *ListValue) XXX_DiscardUnknown() {
xxx_messageInfo_ListValue.DiscardUnknown(m)
}
var xxx_messageInfo_ListValue proto.InternalMessageInfo
func (m *ListValue) GetValues() []*Value {
if m != nil {
return m.Values
}
return nil
}
func init() {
proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
proto.RegisterType((*Value)(nil), "google.protobuf.Value")
proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
}
func init() {
proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_struct_3a5a94e0c7801b27)
}
var fileDescriptor_struct_3a5a94e0c7801b27 = []byte{
// 417 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
0x00,
}

96
vendor/github.com/golang/protobuf/ptypes/struct/struct.proto generated vendored Normal file
View File

@ -0,0 +1,96 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/struct;structpb";
option java_package = "com.google.protobuf";
option java_outer_classname = "StructProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
message Struct {
// Unordered map of dynamically typed values.
map<string, Value> fields = 1;
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
message Value {
// The kind of value.
oneof kind {
// Represents a null value.
NullValue null_value = 1;
// Represents a double value.
double number_value = 2;
// Represents a string value.
string string_value = 3;
// Represents a boolean value.
bool bool_value = 4;
// Represents a structured value.
Struct struct_value = 5;
// Represents a repeated `Value`.
ListValue list_value = 6;
}
}
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
enum NullValue {
// Null value.
NULL_VALUE = 0;
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
message ListValue {
// Repeated field of dynamically typed values.
repeated Value values = 1;
}

443
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go generated vendored Normal file
View File

@ -0,0 +1,443 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/wrappers.proto
package wrappers // import "github.com/golang/protobuf/ptypes/wrappers"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
type DoubleValue struct {
// The double value.
Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DoubleValue) Reset() { *m = DoubleValue{} }
func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
func (*DoubleValue) ProtoMessage() {}
func (*DoubleValue) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{0}
}
func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
}
func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
}
func (dst *DoubleValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_DoubleValue.Merge(dst, src)
}
func (m *DoubleValue) XXX_Size() int {
return xxx_messageInfo_DoubleValue.Size(m)
}
func (m *DoubleValue) XXX_DiscardUnknown() {
xxx_messageInfo_DoubleValue.DiscardUnknown(m)
}
var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
func (m *DoubleValue) GetValue() float64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
type FloatValue struct {
// The float value.
Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FloatValue) Reset() { *m = FloatValue{} }
func (m *FloatValue) String() string { return proto.CompactTextString(m) }
func (*FloatValue) ProtoMessage() {}
func (*FloatValue) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{1}
}
func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
func (m *FloatValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FloatValue.Unmarshal(m, b)
}
func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
}
func (dst *FloatValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_FloatValue.Merge(dst, src)
}
func (m *FloatValue) XXX_Size() int {
return xxx_messageInfo_FloatValue.Size(m)
}
func (m *FloatValue) XXX_DiscardUnknown() {
xxx_messageInfo_FloatValue.DiscardUnknown(m)
}
var xxx_messageInfo_FloatValue proto.InternalMessageInfo
func (m *FloatValue) GetValue() float32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
type Int64Value struct {
// The int64 value.
Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int64Value) Reset() { *m = Int64Value{} }
func (m *Int64Value) String() string { return proto.CompactTextString(m) }
func (*Int64Value) ProtoMessage() {}
func (*Int64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{2}
}
func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
func (m *Int64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int64Value.Unmarshal(m, b)
}
func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
}
func (dst *Int64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int64Value.Merge(dst, src)
}
func (m *Int64Value) XXX_Size() int {
return xxx_messageInfo_Int64Value.Size(m)
}
func (m *Int64Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int64Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int64Value proto.InternalMessageInfo
func (m *Int64Value) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
type UInt64Value struct {
// The uint64 value.
Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt64Value) Reset() { *m = UInt64Value{} }
func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
func (*UInt64Value) ProtoMessage() {}
func (*UInt64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{3}
}
func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
}
func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
}
func (dst *UInt64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt64Value.Merge(dst, src)
}
func (m *UInt64Value) XXX_Size() int {
return xxx_messageInfo_UInt64Value.Size(m)
}
func (m *UInt64Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt64Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
func (m *UInt64Value) GetValue() uint64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
type Int32Value struct {
// The int32 value.
Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int32Value) Reset() { *m = Int32Value{} }
func (m *Int32Value) String() string { return proto.CompactTextString(m) }
func (*Int32Value) ProtoMessage() {}
func (*Int32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{4}
}
func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
func (m *Int32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int32Value.Unmarshal(m, b)
}
func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
}
func (dst *Int32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int32Value.Merge(dst, src)
}
func (m *Int32Value) XXX_Size() int {
return xxx_messageInfo_Int32Value.Size(m)
}
func (m *Int32Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int32Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int32Value proto.InternalMessageInfo
func (m *Int32Value) GetValue() int32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
type UInt32Value struct {
// The uint32 value.
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt32Value) Reset() { *m = UInt32Value{} }
func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
func (*UInt32Value) ProtoMessage() {}
func (*UInt32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{5}
}
func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
}
func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
}
func (dst *UInt32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt32Value.Merge(dst, src)
}
func (m *UInt32Value) XXX_Size() int {
return xxx_messageInfo_UInt32Value.Size(m)
}
func (m *UInt32Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt32Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
func (m *UInt32Value) GetValue() uint32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
type BoolValue struct {
// The bool value.
Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BoolValue) Reset() { *m = BoolValue{} }
func (m *BoolValue) String() string { return proto.CompactTextString(m) }
func (*BoolValue) ProtoMessage() {}
func (*BoolValue) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{6}
}
func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
func (m *BoolValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BoolValue.Unmarshal(m, b)
}
func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
}
func (dst *BoolValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BoolValue.Merge(dst, src)
}
func (m *BoolValue) XXX_Size() int {
return xxx_messageInfo_BoolValue.Size(m)
}
func (m *BoolValue) XXX_DiscardUnknown() {
xxx_messageInfo_BoolValue.DiscardUnknown(m)
}
var xxx_messageInfo_BoolValue proto.InternalMessageInfo
func (m *BoolValue) GetValue() bool {
if m != nil {
return m.Value
}
return false
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
type StringValue struct {
// The string value.
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StringValue) Reset() { *m = StringValue{} }
func (m *StringValue) String() string { return proto.CompactTextString(m) }
func (*StringValue) ProtoMessage() {}
func (*StringValue) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{7}
}
func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
func (m *StringValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StringValue.Unmarshal(m, b)
}
func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
}
func (dst *StringValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_StringValue.Merge(dst, src)
}
func (m *StringValue) XXX_Size() int {
return xxx_messageInfo_StringValue.Size(m)
}
func (m *StringValue) XXX_DiscardUnknown() {
xxx_messageInfo_StringValue.DiscardUnknown(m)
}
var xxx_messageInfo_StringValue proto.InternalMessageInfo
func (m *StringValue) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
type BytesValue struct {
// The bytes value.
Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BytesValue) Reset() { *m = BytesValue{} }
func (m *BytesValue) String() string { return proto.CompactTextString(m) }
func (*BytesValue) ProtoMessage() {}
func (*BytesValue) Descriptor() ([]byte, []int) {
return fileDescriptor_wrappers_16c7c35c009f3253, []int{8}
}
func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
func (m *BytesValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BytesValue.Unmarshal(m, b)
}
func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
}
func (dst *BytesValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BytesValue.Merge(dst, src)
}
func (m *BytesValue) XXX_Size() int {
return xxx_messageInfo_BytesValue.Size(m)
}
func (m *BytesValue) XXX_DiscardUnknown() {
xxx_messageInfo_BytesValue.DiscardUnknown(m)
}
var xxx_messageInfo_BytesValue proto.InternalMessageInfo
func (m *BytesValue) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func init() {
proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
}
func init() {
proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_wrappers_16c7c35c009f3253)
}
var fileDescriptor_wrappers_16c7c35c009f3253 = []byte{
// 259 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
0x01, 0x00, 0x00,
}

118
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto generated vendored Normal file
View File

@ -0,0 +1,118 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Wrappers for primitive (non-message) types. These types are useful
// for embedding primitives in the `google.protobuf.Any` type and for places
// where we need to distinguish between the absence of a primitive
// typed field and its default value.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/wrappers";
option java_package = "com.google.protobuf";
option java_outer_classname = "WrappersProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
message DoubleValue {
// The double value.
double value = 1;
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
message FloatValue {
// The float value.
float value = 1;
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
message Int64Value {
// The int64 value.
int64 value = 1;
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
message UInt64Value {
// The uint64 value.
uint64 value = 1;
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
message Int32Value {
// The int32 value.
int32 value = 1;
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
message UInt32Value {
// The uint32 value.
uint32 value = 1;
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
message BoolValue {
// The bool value.
bool value = 1;
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
message StringValue {
// The string value.
string value = 1;
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
message BytesValue {
// The bytes value.
bytes value = 1;
}

3
vendor/github.com/yandex-cloud/go-genproto/AUTHORS generated vendored Normal file
View File

@ -0,0 +1,3 @@
The following authors have created the source code of "Go generated proto packages" published and distributed by YANDEX LLC as the owner:
Maxim Kolganov <manykey@yandex-team.ru>

21
vendor/github.com/yandex-cloud/go-genproto/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2018 YANDEX LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

109
vendor/github.com/yandex-cloud/go-genproto/yandex/api/operation.pb.go generated vendored Normal file
View File

@ -0,0 +1,109 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/api/operation.proto
package api // import "github.com/yandex-cloud/go-genproto/yandex/api"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// Operation is annotation for rpc that returns longrunning operation, describes
// message types that will be returned in metadata [google.protobuf.Any], and
// in response [google.protobuf.Any] (for successful operation).
type Operation struct {
// Optional. If present, rpc returns operation which metadata field will
// contains message of specified type.
Metadata string `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
// Required. rpc returns operation, in case of success response will contains message of
// specified field.
Response string `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Operation) Reset() { *m = Operation{} }
func (m *Operation) String() string { return proto.CompactTextString(m) }
func (*Operation) ProtoMessage() {}
func (*Operation) Descriptor() ([]byte, []int) {
return fileDescriptor_operation_743b45b46a739ce6, []int{0}
}
func (m *Operation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Operation.Unmarshal(m, b)
}
func (m *Operation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Operation.Marshal(b, m, deterministic)
}
func (dst *Operation) XXX_Merge(src proto.Message) {
xxx_messageInfo_Operation.Merge(dst, src)
}
func (m *Operation) XXX_Size() int {
return xxx_messageInfo_Operation.Size(m)
}
func (m *Operation) XXX_DiscardUnknown() {
xxx_messageInfo_Operation.DiscardUnknown(m)
}
var xxx_messageInfo_Operation proto.InternalMessageInfo
func (m *Operation) GetMetadata() string {
if m != nil {
return m.Metadata
}
return ""
}
func (m *Operation) GetResponse() string {
if m != nil {
return m.Response
}
return ""
}
var E_Operation = &proto.ExtensionDesc{
ExtendedType: (*descriptor.MethodOptions)(nil),
ExtensionType: (*Operation)(nil),
Field: 87334,
Name: "yandex.api.operation",
Tag: "bytes,87334,opt,name=operation",
Filename: "yandex/api/operation.proto",
}
func init() {
proto.RegisterType((*Operation)(nil), "yandex.api.Operation")
proto.RegisterExtension(E_Operation)
}
func init() {
proto.RegisterFile("yandex/api/operation.proto", fileDescriptor_operation_743b45b46a739ce6)
}
var fileDescriptor_operation_743b45b46a739ce6 = []byte{
// 217 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x90, 0x31, 0x4b, 0xc4, 0x40,
0x10, 0x85, 0x89, 0xa0, 0x98, 0xb5, 0x0b, 0x08, 0x21, 0x85, 0x04, 0xab, 0x6b, 0x6e, 0x16, 0x4e,
0x2b, 0xed, 0xb4, 0x96, 0x83, 0x03, 0x1b, 0xbb, 0x49, 0x76, 0xdc, 0x5b, 0xb8, 0xdb, 0x19, 0x76,
0x37, 0xa0, 0x7f, 0xc8, 0xc2, 0x5f, 0x79, 0x24, 0x4b, 0x92, 0xf2, 0xcd, 0xf7, 0x78, 0xef, 0x31,
0xaa, 0xf9, 0x45, 0x6f, 0xe8, 0x47, 0xa3, 0x38, 0xcd, 0x42, 0x01, 0x93, 0x63, 0x0f, 0x12, 0x38,
0x71, 0xa5, 0x32, 0x03, 0x14, 0xd7, 0xb4, 0x96, 0xd9, 0x9e, 0x48, 0x4f, 0xa4, 0x1b, 0xbe, 0xb5,
0xa1, 0xd8, 0x07, 0x27, 0x89, 0x43, 0x76, 0x3f, 0xbe, 0xab, 0x72, 0x3f, 0x07, 0x54, 0x8d, 0xba,
0x3d, 0x53, 0x42, 0x83, 0x09, 0xeb, 0xa2, 0x2d, 0x36, 0xe5, 0x61, 0xd1, 0x23, 0x0b, 0x14, 0x85,
0x7d, 0xa4, 0xfa, 0x2a, 0xb3, 0x59, 0xbf, 0x7c, 0xaa, 0x72, 0x59, 0x51, 0x3d, 0x40, 0x2e, 0x85,
0xb9, 0x14, 0x3e, 0x28, 0x1d, 0xd9, 0xec, 0x65, 0xc4, 0xb1, 0xfe, 0xfb, 0xbf, 0x6e, 0x8b, 0xcd,
0xdd, 0xee, 0x1e, 0xd6, 0xa1, 0xb0, 0x6c, 0x38, 0xac, 0x49, 0x6f, 0xcf, 0x5f, 0x3b, 0xeb, 0xd2,
0x71, 0xe8, 0xa0, 0xe7, 0xb3, 0xce, 0xee, 0x6d, 0x7f, 0xe2, 0xc1, 0x68, 0xcb, 0x5b, 0x4b, 0x7e,
0x6a, 0xd0, 0xeb, 0x2f, 0x5e, 0x51, 0x5c, 0x77, 0x33, 0x5d, 0x9f, 0x2e, 0x01, 0x00, 0x00, 0xff,
0xff, 0x47, 0x3d, 0x10, 0x6e, 0x24, 0x01, 0x00, 0x00,
}

560
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/access/access.pb.go generated vendored Normal file
View File

@ -0,0 +1,560 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/access/access.proto
package access // import "github.com/yandex-cloud/go-genproto/yandex/cloud/access"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type AccessBindingAction int32
const (
AccessBindingAction_ACCESS_BINDING_ACTION_UNSPECIFIED AccessBindingAction = 0
// Addition of an access binding.
AccessBindingAction_ADD AccessBindingAction = 1
// Removal of an access binding.
AccessBindingAction_REMOVE AccessBindingAction = 2
)
var AccessBindingAction_name = map[int32]string{
0: "ACCESS_BINDING_ACTION_UNSPECIFIED",
1: "ADD",
2: "REMOVE",
}
var AccessBindingAction_value = map[string]int32{
"ACCESS_BINDING_ACTION_UNSPECIFIED": 0,
"ADD": 1,
"REMOVE": 2,
}
func (x AccessBindingAction) String() string {
return proto.EnumName(AccessBindingAction_name, int32(x))
}
func (AccessBindingAction) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{0}
}
type Subject struct {
// ID of the subject.
//
// It can contain one of the following values:
// * `allAuthenticatedUsers`: A special system identifier that represents anyone
// who is authenticated. It can be used only if the [type] is `system`.
//
// * `<cloud generated id>`: An identifier that represents a user account.
// It can be used only if the [type] is `userAccount` or `serviceAccount`.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Type of the subject.
//
// It can contain one of the following values:
// * `system`: System group. This type represents several accounts with a common system identifier.
// * `userAccount`: An user account (for example, "alice.the.girl@yandex.ru"). This type represents the [yandex.cloud.iam.v1.UserAccount] resource.
// * `serviceAccount`: A service account. This type represents the [yandex.cloud.iam.v1.ServiceAccount] resource.
//
// For more information, see [Subject to which the role is assigned](/docs/iam/concepts/access-control/#subject).
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Subject) Reset() { *m = Subject{} }
func (m *Subject) String() string { return proto.CompactTextString(m) }
func (*Subject) ProtoMessage() {}
func (*Subject) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{0}
}
func (m *Subject) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Subject.Unmarshal(m, b)
}
func (m *Subject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Subject.Marshal(b, m, deterministic)
}
func (dst *Subject) XXX_Merge(src proto.Message) {
xxx_messageInfo_Subject.Merge(dst, src)
}
func (m *Subject) XXX_Size() int {
return xxx_messageInfo_Subject.Size(m)
}
func (m *Subject) XXX_DiscardUnknown() {
xxx_messageInfo_Subject.DiscardUnknown(m)
}
var xxx_messageInfo_Subject proto.InternalMessageInfo
func (m *Subject) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Subject) GetType() string {
if m != nil {
return m.Type
}
return ""
}
type AccessBinding struct {
// ID of the [yandex.cloud.iam.v1.Role] that is assigned to the [subject].
RoleId string `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
// Identity for which access binding is being created.
// It can represent an account with a unique ID or several accounts with a system identifier.
Subject *Subject `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessBinding) Reset() { *m = AccessBinding{} }
func (m *AccessBinding) String() string { return proto.CompactTextString(m) }
func (*AccessBinding) ProtoMessage() {}
func (*AccessBinding) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{1}
}
func (m *AccessBinding) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessBinding.Unmarshal(m, b)
}
func (m *AccessBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessBinding.Marshal(b, m, deterministic)
}
func (dst *AccessBinding) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessBinding.Merge(dst, src)
}
func (m *AccessBinding) XXX_Size() int {
return xxx_messageInfo_AccessBinding.Size(m)
}
func (m *AccessBinding) XXX_DiscardUnknown() {
xxx_messageInfo_AccessBinding.DiscardUnknown(m)
}
var xxx_messageInfo_AccessBinding proto.InternalMessageInfo
func (m *AccessBinding) GetRoleId() string {
if m != nil {
return m.RoleId
}
return ""
}
func (m *AccessBinding) GetSubject() *Subject {
if m != nil {
return m.Subject
}
return nil
}
type ListAccessBindingsRequest struct {
// ID of the resource to list access bindings for.
//
// To get the resource ID, use a corresponding List request.
// For example, use the [yandex.cloud.resourcemanager.v1.CloudService.List] request to get the Cloud resource ID.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// The maximum number of results per page that should be returned. If the number of available
// results is larger than [page_size],
// the service returns a [ListAccessBindingsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. Set [page_token]
// to the [ListAccessBindingsResponse.next_page_token]
// returned by a previous list request to get the next page of results.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessBindingsRequest) Reset() { *m = ListAccessBindingsRequest{} }
func (m *ListAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*ListAccessBindingsRequest) ProtoMessage() {}
func (*ListAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{2}
}
func (m *ListAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessBindingsRequest.Unmarshal(m, b)
}
func (m *ListAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *ListAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessBindingsRequest.Merge(dst, src)
}
func (m *ListAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_ListAccessBindingsRequest.Size(m)
}
func (m *ListAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessBindingsRequest proto.InternalMessageInfo
func (m *ListAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *ListAccessBindingsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListAccessBindingsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListAccessBindingsResponse struct {
// List of access bindings for the specified resource.
AccessBindings []*AccessBinding `protobuf:"bytes,1,rep,name=access_bindings,json=accessBindings,proto3" json:"access_bindings,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListAccessBindingsRequest.page_size], use
// the [next_page_token] as the value
// for the [ListAccessBindingsRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessBindingsResponse) Reset() { *m = ListAccessBindingsResponse{} }
func (m *ListAccessBindingsResponse) String() string { return proto.CompactTextString(m) }
func (*ListAccessBindingsResponse) ProtoMessage() {}
func (*ListAccessBindingsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{3}
}
func (m *ListAccessBindingsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessBindingsResponse.Unmarshal(m, b)
}
func (m *ListAccessBindingsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessBindingsResponse.Marshal(b, m, deterministic)
}
func (dst *ListAccessBindingsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessBindingsResponse.Merge(dst, src)
}
func (m *ListAccessBindingsResponse) XXX_Size() int {
return xxx_messageInfo_ListAccessBindingsResponse.Size(m)
}
func (m *ListAccessBindingsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessBindingsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessBindingsResponse proto.InternalMessageInfo
func (m *ListAccessBindingsResponse) GetAccessBindings() []*AccessBinding {
if m != nil {
return m.AccessBindings
}
return nil
}
func (m *ListAccessBindingsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type SetAccessBindingsRequest struct {
// ID of the resource for which access bindings are being set.
//
// To get the resource ID, use a corresponding List request.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// Access bindings to be set. For more information, see [Access Bindings](/docs/iam/concepts/access-control/#access-bindings).
AccessBindings []*AccessBinding `protobuf:"bytes,2,rep,name=access_bindings,json=accessBindings,proto3" json:"access_bindings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetAccessBindingsRequest) Reset() { *m = SetAccessBindingsRequest{} }
func (m *SetAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*SetAccessBindingsRequest) ProtoMessage() {}
func (*SetAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{4}
}
func (m *SetAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetAccessBindingsRequest.Unmarshal(m, b)
}
func (m *SetAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *SetAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetAccessBindingsRequest.Merge(dst, src)
}
func (m *SetAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_SetAccessBindingsRequest.Size(m)
}
func (m *SetAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetAccessBindingsRequest proto.InternalMessageInfo
func (m *SetAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *SetAccessBindingsRequest) GetAccessBindings() []*AccessBinding {
if m != nil {
return m.AccessBindings
}
return nil
}
type SetAccessBindingsMetadata struct {
// ID of the resource for which access bindings are being set.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetAccessBindingsMetadata) Reset() { *m = SetAccessBindingsMetadata{} }
func (m *SetAccessBindingsMetadata) String() string { return proto.CompactTextString(m) }
func (*SetAccessBindingsMetadata) ProtoMessage() {}
func (*SetAccessBindingsMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{5}
}
func (m *SetAccessBindingsMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetAccessBindingsMetadata.Unmarshal(m, b)
}
func (m *SetAccessBindingsMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetAccessBindingsMetadata.Marshal(b, m, deterministic)
}
func (dst *SetAccessBindingsMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetAccessBindingsMetadata.Merge(dst, src)
}
func (m *SetAccessBindingsMetadata) XXX_Size() int {
return xxx_messageInfo_SetAccessBindingsMetadata.Size(m)
}
func (m *SetAccessBindingsMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_SetAccessBindingsMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_SetAccessBindingsMetadata proto.InternalMessageInfo
func (m *SetAccessBindingsMetadata) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
type UpdateAccessBindingsRequest struct {
// ID of the resource for which access bindings are being updated.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// Updates to access bindings.
AccessBindingDeltas []*AccessBindingDelta `protobuf:"bytes,2,rep,name=access_binding_deltas,json=accessBindingDeltas,proto3" json:"access_binding_deltas,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateAccessBindingsRequest) Reset() { *m = UpdateAccessBindingsRequest{} }
func (m *UpdateAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateAccessBindingsRequest) ProtoMessage() {}
func (*UpdateAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{6}
}
func (m *UpdateAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateAccessBindingsRequest.Unmarshal(m, b)
}
func (m *UpdateAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateAccessBindingsRequest.Merge(dst, src)
}
func (m *UpdateAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_UpdateAccessBindingsRequest.Size(m)
}
func (m *UpdateAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateAccessBindingsRequest proto.InternalMessageInfo
func (m *UpdateAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *UpdateAccessBindingsRequest) GetAccessBindingDeltas() []*AccessBindingDelta {
if m != nil {
return m.AccessBindingDeltas
}
return nil
}
type UpdateAccessBindingsMetadata struct {
// ID of the resource for which access bindings are being updated.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateAccessBindingsMetadata) Reset() { *m = UpdateAccessBindingsMetadata{} }
func (m *UpdateAccessBindingsMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateAccessBindingsMetadata) ProtoMessage() {}
func (*UpdateAccessBindingsMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{7}
}
func (m *UpdateAccessBindingsMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Unmarshal(m, b)
}
func (m *UpdateAccessBindingsMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateAccessBindingsMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateAccessBindingsMetadata.Merge(dst, src)
}
func (m *UpdateAccessBindingsMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Size(m)
}
func (m *UpdateAccessBindingsMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateAccessBindingsMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateAccessBindingsMetadata proto.InternalMessageInfo
func (m *UpdateAccessBindingsMetadata) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
type AccessBindingDelta struct {
// The action that is being performed on an access binding.
Action AccessBindingAction `protobuf:"varint,1,opt,name=action,proto3,enum=yandex.cloud.access.AccessBindingAction" json:"action,omitempty"`
// Access binding. For more information, see [Access Bindings](/docs/iam/concepts/access-control/#access-bindings).
AccessBinding *AccessBinding `protobuf:"bytes,2,opt,name=access_binding,json=accessBinding,proto3" json:"access_binding,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessBindingDelta) Reset() { *m = AccessBindingDelta{} }
func (m *AccessBindingDelta) String() string { return proto.CompactTextString(m) }
func (*AccessBindingDelta) ProtoMessage() {}
func (*AccessBindingDelta) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{8}
}
func (m *AccessBindingDelta) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessBindingDelta.Unmarshal(m, b)
}
func (m *AccessBindingDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessBindingDelta.Marshal(b, m, deterministic)
}
func (dst *AccessBindingDelta) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessBindingDelta.Merge(dst, src)
}
func (m *AccessBindingDelta) XXX_Size() int {
return xxx_messageInfo_AccessBindingDelta.Size(m)
}
func (m *AccessBindingDelta) XXX_DiscardUnknown() {
xxx_messageInfo_AccessBindingDelta.DiscardUnknown(m)
}
var xxx_messageInfo_AccessBindingDelta proto.InternalMessageInfo
func (m *AccessBindingDelta) GetAction() AccessBindingAction {
if m != nil {
return m.Action
}
return AccessBindingAction_ACCESS_BINDING_ACTION_UNSPECIFIED
}
func (m *AccessBindingDelta) GetAccessBinding() *AccessBinding {
if m != nil {
return m.AccessBinding
}
return nil
}
func init() {
proto.RegisterType((*Subject)(nil), "yandex.cloud.access.Subject")
proto.RegisterType((*AccessBinding)(nil), "yandex.cloud.access.AccessBinding")
proto.RegisterType((*ListAccessBindingsRequest)(nil), "yandex.cloud.access.ListAccessBindingsRequest")
proto.RegisterType((*ListAccessBindingsResponse)(nil), "yandex.cloud.access.ListAccessBindingsResponse")
proto.RegisterType((*SetAccessBindingsRequest)(nil), "yandex.cloud.access.SetAccessBindingsRequest")
proto.RegisterType((*SetAccessBindingsMetadata)(nil), "yandex.cloud.access.SetAccessBindingsMetadata")
proto.RegisterType((*UpdateAccessBindingsRequest)(nil), "yandex.cloud.access.UpdateAccessBindingsRequest")
proto.RegisterType((*UpdateAccessBindingsMetadata)(nil), "yandex.cloud.access.UpdateAccessBindingsMetadata")
proto.RegisterType((*AccessBindingDelta)(nil), "yandex.cloud.access.AccessBindingDelta")
proto.RegisterEnum("yandex.cloud.access.AccessBindingAction", AccessBindingAction_name, AccessBindingAction_value)
}
func init() {
proto.RegisterFile("yandex/cloud/access/access.proto", fileDescriptor_access_6c04a92fd5da6f4f)
}
var fileDescriptor_access_6c04a92fd5da6f4f = []byte{
// 579 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcf, 0x6e, 0xd3, 0x4c,
0x14, 0xc5, 0x3f, 0x27, 0xfd, 0x92, 0xe6, 0x86, 0xa4, 0xd1, 0x44, 0x48, 0x6e, 0x29, 0x22, 0xb5,
0x04, 0x8d, 0x90, 0xe2, 0xfc, 0x41, 0x88, 0x05, 0x29, 0x10, 0x27, 0x29, 0xb2, 0xa0, 0x49, 0x6b,
0xb7, 0x2c, 0xd8, 0x58, 0x13, 0xcf, 0x28, 0x18, 0x82, 0x6d, 0x32, 0x13, 0xd4, 0xf6, 0x11, 0xba,
0x63, 0x0f, 0x8f, 0x80, 0x78, 0x8c, 0xf6, 0x51, 0x78, 0x06, 0x56, 0xc8, 0x63, 0xa7, 0x8a, 0x89,
0xa5, 0x66, 0xd1, 0xd5, 0x58, 0xbe, 0xe7, 0x9e, 0xfb, 0x3b, 0x33, 0x9a, 0x81, 0xca, 0x19, 0x76,
0x09, 0x3d, 0xad, 0xdb, 0x13, 0x6f, 0x46, 0xea, 0xd8, 0xb6, 0x29, 0x63, 0xd1, 0xa2, 0xfa, 0x53,
0x8f, 0x7b, 0xa8, 0x1c, 0x2a, 0x54, 0xa1, 0x50, 0xc3, 0xd2, 0xd6, 0xfd, 0x58, 0xdb, 0x57, 0x3c,
0x71, 0x08, 0xe6, 0x8e, 0xe7, 0x86, 0x3d, 0xca, 0x33, 0xc8, 0x9a, 0xb3, 0xd1, 0x47, 0x6a, 0x73,
0x24, 0x43, 0xca, 0x21, 0xb2, 0x54, 0x91, 0xaa, 0x39, 0x6d, 0xfd, 0xe2, 0xaa, 0xb9, 0xd6, 0xde,
0x7b, 0xda, 0x30, 0x52, 0x0e, 0x41, 0x08, 0xd6, 0xf8, 0x99, 0x4f, 0xe5, 0x54, 0x50, 0x33, 0xc4,
0xb7, 0xe2, 0x43, 0xa1, 0x23, 0x26, 0x68, 0x8e, 0x4b, 0x1c, 0x77, 0x8c, 0x76, 0x20, 0x3b, 0xf5,
0x26, 0xd4, 0x4a, 0xf0, 0xc8, 0x04, 0x05, 0x9d, 0xa0, 0x36, 0x64, 0x59, 0x38, 0x4c, 0x58, 0xe5,
0x5b, 0xdb, 0x6a, 0x02, 0xb2, 0x1a, 0x01, 0x69, 0x6b, 0xbf, 0x2f, 0x9b, 0x92, 0x31, 0x6f, 0x51,
0x7e, 0x48, 0xb0, 0xf9, 0xd6, 0x61, 0x3c, 0x36, 0x96, 0x19, 0xf4, 0xcb, 0x8c, 0x32, 0x8e, 0x6a,
0x90, 0x9f, 0x52, 0xe6, 0xcd, 0xa6, 0xf6, 0x02, 0xc2, 0x9d, 0xc0, 0xe1, 0x1a, 0x03, 0xe6, 0x02,
0x9d, 0xa0, 0x5d, 0xc8, 0xf9, 0x78, 0x4c, 0x2d, 0xe6, 0x9c, 0x87, 0xb9, 0xd2, 0x1a, 0xfc, 0xb9,
0x6c, 0x66, 0xda, 0x7b, 0xcd, 0x46, 0xa3, 0x61, 0xac, 0x07, 0x45, 0xd3, 0x39, 0xa7, 0xa8, 0x0a,
0x20, 0x84, 0xdc, 0xfb, 0x44, 0x5d, 0x39, 0x2d, 0x6c, 0x73, 0x17, 0x57, 0xcd, 0xff, 0x85, 0xd2,
0x10, 0x2e, 0xc7, 0x41, 0x4d, 0xf9, 0x26, 0xc1, 0x56, 0x12, 0x1f, 0xf3, 0x3d, 0x97, 0x51, 0xf4,
0x06, 0x36, 0xc2, 0x7c, 0xd6, 0x28, 0x2a, 0xc9, 0x52, 0x25, 0x5d, 0xcd, 0xb7, 0x94, 0xc4, 0x4d,
0x88, 0xb9, 0x18, 0x45, 0x1c, 0x33, 0x45, 0x8f, 0x60, 0xc3, 0xa5, 0xa7, 0xdc, 0x5a, 0x40, 0x0b,
0x0f, 0xa7, 0x10, 0xfc, 0x3e, 0xbc, 0x66, 0xfa, 0x2e, 0x81, 0x6c, 0xd2, 0xdb, 0xd9, 0xb2, 0xa3,
0xe5, 0x00, 0xa9, 0x55, 0x03, 0x44, 0x67, 0xf9, 0x4f, 0x0c, 0xa5, 0x0d, 0x9b, 0x4b, 0x74, 0x07,
0x94, 0x63, 0x82, 0x39, 0x46, 0x0f, 0x12, 0xf0, 0x16, 0x81, 0x94, 0x5f, 0x12, 0xdc, 0x3b, 0xf1,
0x09, 0xe6, 0xf4, 0x56, 0xf2, 0x61, 0xb8, 0x1b, 0xcf, 0x67, 0x11, 0x3a, 0xe1, 0x78, 0x9e, 0x72,
0xf7, 0xe6, 0x94, 0xbd, 0x40, 0x1f, 0x45, 0x2d, 0xe3, 0xa5, 0x0a, 0x53, 0x5e, 0xc2, 0x76, 0x12,
0xf0, 0xea, 0x91, 0x7f, 0x4a, 0x80, 0x96, 0x47, 0xa2, 0x7d, 0xc8, 0x60, 0x3b, 0xb8, 0xd5, 0xa2,
0xa5, 0xd8, 0xaa, 0xde, 0xcc, 0xda, 0x11, 0xfa, 0x08, 0x36, 0xea, 0x46, 0x43, 0x28, 0xc6, 0xb7,
0x20, 0xba, 0xa7, 0xab, 0x9f, 0x70, 0x21, 0x16, 0xfb, 0xf1, 0x11, 0x94, 0x13, 0xa6, 0xa2, 0x87,
0xb0, 0xd3, 0xe9, 0x76, 0xfb, 0xa6, 0x69, 0x69, 0xfa, 0xa0, 0xa7, 0x0f, 0x5e, 0x5b, 0x9d, 0xee,
0xb1, 0x3e, 0x1c, 0x58, 0x27, 0x03, 0xf3, 0xb0, 0xdf, 0xd5, 0xf7, 0xf5, 0x7e, 0xaf, 0xf4, 0x1f,
0xca, 0x42, 0xba, 0xd3, 0xeb, 0x95, 0x24, 0x04, 0x90, 0x31, 0xfa, 0x07, 0xc3, 0x77, 0xfd, 0x52,
0x4a, 0x7b, 0xf5, 0xfe, 0xc5, 0xd8, 0xe1, 0x1f, 0x66, 0x23, 0xd5, 0xf6, 0x3e, 0xd7, 0x43, 0xae,
0x5a, 0xf8, 0xba, 0x8d, 0xbd, 0xda, 0x98, 0xba, 0xe2, 0x61, 0xab, 0x27, 0xbc, 0x96, 0xcf, 0xc3,
0x65, 0x94, 0x11, 0x8a, 0x27, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc3, 0xce, 0x12, 0xcf, 0x52,
0x05, 0x00, 0x00,
}

356
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk.pb.go generated vendored Normal file
View File

@ -0,0 +1,356 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Disk_Status int32
const (
Disk_STATUS_UNSPECIFIED Disk_Status = 0
// Disk is being created.
Disk_CREATING Disk_Status = 1
// Disk is ready to use.
Disk_READY Disk_Status = 2
// Disk encountered a problem and cannot operate.
Disk_ERROR Disk_Status = 3
// Disk is being deleted.
Disk_DELETING Disk_Status = 4
)
var Disk_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Disk_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Disk_Status) String() string {
return proto.EnumName(Disk_Status_name, int32(x))
}
func (Disk_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_disk_de2270285e4895a2, []int{0, 0}
}
// A Disk resource. For more information, see [Disks](/docs/compute/concepts/disk).
type Disk struct {
// ID of the disk.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the disk belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the disk. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the disk. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the disk type.
TypeId string `protobuf:"bytes,7,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"`
// ID of the availability zone where the disk resides.
ZoneId string `protobuf:"bytes,8,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// Size of the disk, specified in bytes.
Size int64 `protobuf:"varint,9,opt,name=size,proto3" json:"size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,10,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the disk.
Status Disk_Status `protobuf:"varint,11,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Disk_Status" json:"status,omitempty"`
// Types that are valid to be assigned to Source:
// *Disk_SourceImageId
// *Disk_SourceSnapshotId
Source isDisk_Source `protobuf_oneof:"source"`
// Array of instances to which the disk is attached.
InstanceIds []string `protobuf:"bytes,14,rep,name=instance_ids,json=instanceIds,proto3" json:"instance_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Disk) Reset() { *m = Disk{} }
func (m *Disk) String() string { return proto.CompactTextString(m) }
func (*Disk) ProtoMessage() {}
func (*Disk) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_de2270285e4895a2, []int{0}
}
func (m *Disk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Disk.Unmarshal(m, b)
}
func (m *Disk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Disk.Marshal(b, m, deterministic)
}
func (dst *Disk) XXX_Merge(src proto.Message) {
xxx_messageInfo_Disk.Merge(dst, src)
}
func (m *Disk) XXX_Size() int {
return xxx_messageInfo_Disk.Size(m)
}
func (m *Disk) XXX_DiscardUnknown() {
xxx_messageInfo_Disk.DiscardUnknown(m)
}
var xxx_messageInfo_Disk proto.InternalMessageInfo
func (m *Disk) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Disk) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Disk) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Disk) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Disk) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Disk) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Disk) GetTypeId() string {
if m != nil {
return m.TypeId
}
return ""
}
func (m *Disk) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Disk) GetSize() int64 {
if m != nil {
return m.Size
}
return 0
}
func (m *Disk) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Disk) GetStatus() Disk_Status {
if m != nil {
return m.Status
}
return Disk_STATUS_UNSPECIFIED
}
type isDisk_Source interface {
isDisk_Source()
}
type Disk_SourceImageId struct {
SourceImageId string `protobuf:"bytes,12,opt,name=source_image_id,json=sourceImageId,proto3,oneof"`
}
type Disk_SourceSnapshotId struct {
SourceSnapshotId string `protobuf:"bytes,13,opt,name=source_snapshot_id,json=sourceSnapshotId,proto3,oneof"`
}
func (*Disk_SourceImageId) isDisk_Source() {}
func (*Disk_SourceSnapshotId) isDisk_Source() {}
func (m *Disk) GetSource() isDisk_Source {
if m != nil {
return m.Source
}
return nil
}
func (m *Disk) GetSourceImageId() string {
if x, ok := m.GetSource().(*Disk_SourceImageId); ok {
return x.SourceImageId
}
return ""
}
func (m *Disk) GetSourceSnapshotId() string {
if x, ok := m.GetSource().(*Disk_SourceSnapshotId); ok {
return x.SourceSnapshotId
}
return ""
}
func (m *Disk) GetInstanceIds() []string {
if m != nil {
return m.InstanceIds
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Disk) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Disk_OneofMarshaler, _Disk_OneofUnmarshaler, _Disk_OneofSizer, []interface{}{
(*Disk_SourceImageId)(nil),
(*Disk_SourceSnapshotId)(nil),
}
}
func _Disk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Disk)
// source
switch x := m.Source.(type) {
case *Disk_SourceImageId:
b.EncodeVarint(12<<3 | proto.WireBytes)
b.EncodeStringBytes(x.SourceImageId)
case *Disk_SourceSnapshotId:
b.EncodeVarint(13<<3 | proto.WireBytes)
b.EncodeStringBytes(x.SourceSnapshotId)
case nil:
default:
return fmt.Errorf("Disk.Source has unexpected type %T", x)
}
return nil
}
func _Disk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Disk)
switch tag {
case 12: // source.source_image_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Source = &Disk_SourceImageId{x}
return true, err
case 13: // source.source_snapshot_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Source = &Disk_SourceSnapshotId{x}
return true, err
default:
return false, nil
}
}
func _Disk_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Disk)
// source
switch x := m.Source.(type) {
case *Disk_SourceImageId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.SourceImageId)))
n += len(x.SourceImageId)
case *Disk_SourceSnapshotId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.SourceSnapshotId)))
n += len(x.SourceSnapshotId)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*Disk)(nil), "yandex.cloud.compute.v1.Disk")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Disk.LabelsEntry")
proto.RegisterEnum("yandex.cloud.compute.v1.Disk_Status", Disk_Status_name, Disk_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk.proto", fileDescriptor_disk_de2270285e4895a2)
}
var fileDescriptor_disk_de2270285e4895a2 = []byte{
// 533 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x41, 0x4f, 0xdb, 0x3e,
0x18, 0xc6, 0x49, 0xd3, 0x86, 0xe6, 0x0d, 0xf0, 0x8f, 0xac, 0xbf, 0x46, 0xc4, 0x0e, 0x64, 0x68,
0x87, 0xec, 0x40, 0x22, 0xd8, 0x65, 0x6c, 0xbb, 0x14, 0x9a, 0x6d, 0x91, 0x10, 0x9b, 0xdc, 0x72,
0xd8, 0x2e, 0x55, 0x1a, 0x9b, 0x60, 0x35, 0x8d, 0xa3, 0xd8, 0xa9, 0x56, 0x3e, 0xce, 0x3e, 0xe9,
0x64, 0x3b, 0x95, 0xb8, 0xb0, 0xdb, 0xeb, 0xe7, 0xf9, 0xd9, 0xef, 0xf3, 0x5a, 0x36, 0x9c, 0x6d,
0xf3, 0x9a, 0xd0, 0xdf, 0x49, 0x51, 0xf1, 0x8e, 0x24, 0x05, 0x5f, 0x37, 0x9d, 0xa4, 0xc9, 0xe6,
0x22, 0x21, 0x4c, 0xac, 0xe2, 0xa6, 0xe5, 0x92, 0xa3, 0x63, 0xc3, 0xc4, 0x9a, 0x89, 0x7b, 0x26,
0xde, 0x5c, 0x9c, 0x9c, 0x96, 0x9c, 0x97, 0x15, 0x4d, 0x34, 0xb6, 0xec, 0x1e, 0x12, 0xc9, 0xd6,
0x54, 0xc8, 0x7c, 0xdd, 0x98, 0x9d, 0x67, 0x7f, 0x46, 0x30, 0x9c, 0x32, 0xb1, 0x42, 0x47, 0x30,
0x60, 0x24, 0xb0, 0x42, 0x2b, 0x72, 0xf1, 0x80, 0x11, 0xf4, 0x1a, 0xdc, 0x07, 0x5e, 0x11, 0xda,
0x2e, 0x18, 0x09, 0x06, 0x5a, 0x1e, 0x1b, 0x21, 0x23, 0xe8, 0x0a, 0xa0, 0x68, 0x69, 0x2e, 0x29,
0x59, 0xe4, 0x32, 0xb0, 0x43, 0x2b, 0xf2, 0x2e, 0x4f, 0x62, 0xd3, 0x2b, 0xde, 0xf5, 0x8a, 0xe7,
0xbb, 0x5e, 0xd8, 0xed, 0xe9, 0x89, 0x44, 0x08, 0x86, 0x75, 0xbe, 0xa6, 0xc1, 0x50, 0x1f, 0xa9,
0x6b, 0x14, 0x82, 0x47, 0xa8, 0x28, 0x5a, 0xd6, 0x48, 0xc6, 0xeb, 0x60, 0xa4, 0xad, 0xe7, 0x12,
0x9a, 0x80, 0x53, 0xe5, 0x4b, 0x5a, 0x89, 0xc0, 0x09, 0xed, 0xc8, 0xbb, 0x7c, 0x17, 0xbf, 0x30,
0x71, 0xac, 0x86, 0x89, 0x6f, 0x35, 0x9b, 0xd6, 0xb2, 0xdd, 0xe2, 0x7e, 0x23, 0x3a, 0x86, 0x7d,
0xb9, 0x6d, 0xa8, 0x1a, 0x67, 0x5f, 0x37, 0x70, 0xd4, 0x32, 0x23, 0xca, 0x78, 0xe2, 0xb5, 0x36,
0xc6, 0xc6, 0x50, 0xcb, 0x8c, 0xa8, 0xa8, 0x82, 0x3d, 0xd1, 0xc0, 0x0d, 0xad, 0xc8, 0xc6, 0xba,
0x46, 0xa7, 0xe0, 0x35, 0x2d, 0x27, 0x5d, 0x21, 0x17, 0x8c, 0x88, 0x00, 0x42, 0x3b, 0x72, 0x31,
0xf4, 0x52, 0x46, 0x04, 0xfa, 0x0c, 0x8e, 0x90, 0xb9, 0xec, 0x44, 0xe0, 0x85, 0x56, 0x74, 0x74,
0xf9, 0xf6, 0xdf, 0x49, 0x67, 0x9a, 0xc5, 0xfd, 0x1e, 0x14, 0xc1, 0x7f, 0x82, 0x77, 0x6d, 0x41,
0x17, 0x6c, 0x9d, 0x97, 0x3a, 0xd3, 0x81, 0xca, 0xf4, 0x6d, 0x0f, 0x1f, 0x1a, 0x23, 0x53, 0x7a,
0x46, 0x50, 0x0c, 0xa8, 0x27, 0x45, 0x9d, 0x37, 0xe2, 0x91, 0xab, 0x40, 0xc1, 0x61, 0x0f, 0xfb,
0xc6, 0x9b, 0xf5, 0x56, 0x46, 0xd0, 0x1b, 0x38, 0x60, 0xb5, 0x90, 0x79, 0xad, 0xce, 0x26, 0x22,
0x38, 0xd2, 0xc9, 0xbd, 0x9d, 0x96, 0x11, 0x71, 0x72, 0x05, 0xde, 0xb3, 0x8b, 0x43, 0x3e, 0xd8,
0x2b, 0xba, 0xed, 0x9f, 0x84, 0x2a, 0xd1, 0xff, 0x30, 0xda, 0xe4, 0x55, 0x47, 0xfb, 0xf7, 0x60,
0x16, 0x1f, 0x07, 0x1f, 0xac, 0x33, 0x0c, 0x8e, 0x99, 0x04, 0xbd, 0x02, 0x34, 0x9b, 0x4f, 0xe6,
0xf7, 0xb3, 0xc5, 0xfd, 0xdd, 0xec, 0x47, 0x7a, 0x93, 0x7d, 0xc9, 0xd2, 0xa9, 0xbf, 0x87, 0x0e,
0x60, 0x7c, 0x83, 0xd3, 0xc9, 0x3c, 0xbb, 0xfb, 0xea, 0x5b, 0xc8, 0x85, 0x11, 0x4e, 0x27, 0xd3,
0x9f, 0xfe, 0x40, 0x95, 0x29, 0xc6, 0xdf, 0xb1, 0x6f, 0x2b, 0x66, 0x9a, 0xde, 0xa6, 0x9a, 0x19,
0x5e, 0x8f, 0xc1, 0x31, 0x53, 0x5c, 0xa7, 0xbf, 0x6e, 0x4a, 0x26, 0x1f, 0xbb, 0xa5, 0xba, 0xbe,
0xc4, 0xdc, 0xe7, 0xb9, 0xf9, 0x0f, 0x25, 0x3f, 0x2f, 0x69, 0xad, 0x9f, 0x5c, 0xf2, 0xc2, 0x47,
0xf9, 0xd4, 0x97, 0x4b, 0x47, 0x63, 0xef, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xe9, 0x4b,
0xc4, 0x52, 0x03, 0x00, 0x00,
}

1118
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

100
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type.pb.go generated vendored Normal file
View File

@ -0,0 +1,100 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk_type.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
type DiskType struct {
// ID of the disk type.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Description of the disk type. 0-256 characters long.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Array of availability zones where the disk type is available.
ZoneIds []string `protobuf:"bytes,3,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DiskType) Reset() { *m = DiskType{} }
func (m *DiskType) String() string { return proto.CompactTextString(m) }
func (*DiskType) ProtoMessage() {}
func (*DiskType) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_5be272c1e4d4338f, []int{0}
}
func (m *DiskType) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DiskType.Unmarshal(m, b)
}
func (m *DiskType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DiskType.Marshal(b, m, deterministic)
}
func (dst *DiskType) XXX_Merge(src proto.Message) {
xxx_messageInfo_DiskType.Merge(dst, src)
}
func (m *DiskType) XXX_Size() int {
return xxx_messageInfo_DiskType.Size(m)
}
func (m *DiskType) XXX_DiscardUnknown() {
xxx_messageInfo_DiskType.DiscardUnknown(m)
}
var xxx_messageInfo_DiskType proto.InternalMessageInfo
func (m *DiskType) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *DiskType) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *DiskType) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func init() {
proto.RegisterType((*DiskType)(nil), "yandex.cloud.compute.v1.DiskType")
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk_type.proto", fileDescriptor_disk_type_5be272c1e4d4338f)
}
var fileDescriptor_disk_type_5be272c1e4d4338f = []byte{
// 190 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xaf, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2d, 0x28, 0x2d, 0x49,
0xd5, 0x2f, 0x33, 0xd4, 0x4f, 0xc9, 0x2c, 0xce, 0x8e, 0x2f, 0xa9, 0x2c, 0x48, 0xd5, 0x2b, 0x28,
0xca, 0x2f, 0xc9, 0x17, 0x12, 0x87, 0x28, 0xd4, 0x03, 0x2b, 0xd4, 0x83, 0x2a, 0xd4, 0x2b, 0x33,
0x54, 0x0a, 0xe7, 0xe2, 0x70, 0xc9, 0x2c, 0xce, 0x0e, 0xa9, 0x2c, 0x48, 0x15, 0xe2, 0xe3, 0x62,
0xca, 0x4c, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0xca, 0x4c, 0x11, 0x52, 0xe0, 0xe2,
0x4e, 0x49, 0x2d, 0x4e, 0x2e, 0xca, 0x2c, 0x28, 0xc9, 0xcc, 0xcf, 0x93, 0x60, 0x02, 0x4b, 0x20,
0x0b, 0x09, 0x49, 0x72, 0x71, 0x54, 0xe5, 0xe7, 0xa5, 0xc6, 0x67, 0xa6, 0x14, 0x4b, 0x30, 0x2b,
0x30, 0x6b, 0x70, 0x06, 0xb1, 0x83, 0xf8, 0x9e, 0x29, 0xc5, 0x4e, 0xae, 0x51, 0xce, 0xe9, 0x99,
0x25, 0x19, 0xa5, 0x49, 0x20, 0xdb, 0xf4, 0x21, 0xd6, 0xeb, 0x42, 0xdc, 0x99, 0x9e, 0xaf, 0x9b,
0x9e, 0x9a, 0x07, 0x76, 0x98, 0x3e, 0x0e, 0x0f, 0x58, 0x43, 0x99, 0x49, 0x6c, 0x60, 0x65, 0xc6,
0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x85, 0x4f, 0x91, 0xea, 0x00, 0x00, 0x00,
}

325
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,325 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk_type_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDiskTypeRequest struct {
// ID of the disk type to return information about.
// To get the disk type ID use a [DiskTypeService.List] request.
DiskTypeId string `protobuf:"bytes,1,opt,name=disk_type_id,json=diskTypeId,proto3" json:"disk_type_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDiskTypeRequest) Reset() { *m = GetDiskTypeRequest{} }
func (m *GetDiskTypeRequest) String() string { return proto.CompactTextString(m) }
func (*GetDiskTypeRequest) ProtoMessage() {}
func (*GetDiskTypeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{0}
}
func (m *GetDiskTypeRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDiskTypeRequest.Unmarshal(m, b)
}
func (m *GetDiskTypeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDiskTypeRequest.Marshal(b, m, deterministic)
}
func (dst *GetDiskTypeRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDiskTypeRequest.Merge(dst, src)
}
func (m *GetDiskTypeRequest) XXX_Size() int {
return xxx_messageInfo_GetDiskTypeRequest.Size(m)
}
func (m *GetDiskTypeRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDiskTypeRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDiskTypeRequest proto.InternalMessageInfo
func (m *GetDiskTypeRequest) GetDiskTypeId() string {
if m != nil {
return m.DiskTypeId
}
return ""
}
type ListDiskTypesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListDiskTypesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListDiskTypesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDiskTypesRequest) Reset() { *m = ListDiskTypesRequest{} }
func (m *ListDiskTypesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDiskTypesRequest) ProtoMessage() {}
func (*ListDiskTypesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{1}
}
func (m *ListDiskTypesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDiskTypesRequest.Unmarshal(m, b)
}
func (m *ListDiskTypesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDiskTypesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDiskTypesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDiskTypesRequest.Merge(dst, src)
}
func (m *ListDiskTypesRequest) XXX_Size() int {
return xxx_messageInfo_ListDiskTypesRequest.Size(m)
}
func (m *ListDiskTypesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDiskTypesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDiskTypesRequest proto.InternalMessageInfo
func (m *ListDiskTypesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDiskTypesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDiskTypesResponse struct {
// List of disk types.
DiskTypes []*DiskType `protobuf:"bytes,1,rep,name=disk_types,json=diskTypes,proto3" json:"disk_types,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDiskTypesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListDiskTypesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDiskTypesResponse) Reset() { *m = ListDiskTypesResponse{} }
func (m *ListDiskTypesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDiskTypesResponse) ProtoMessage() {}
func (*ListDiskTypesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{2}
}
func (m *ListDiskTypesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDiskTypesResponse.Unmarshal(m, b)
}
func (m *ListDiskTypesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDiskTypesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDiskTypesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDiskTypesResponse.Merge(dst, src)
}
func (m *ListDiskTypesResponse) XXX_Size() int {
return xxx_messageInfo_ListDiskTypesResponse.Size(m)
}
func (m *ListDiskTypesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDiskTypesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDiskTypesResponse proto.InternalMessageInfo
func (m *ListDiskTypesResponse) GetDiskTypes() []*DiskType {
if m != nil {
return m.DiskTypes
}
return nil
}
func (m *ListDiskTypesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetDiskTypeRequest)(nil), "yandex.cloud.compute.v1.GetDiskTypeRequest")
proto.RegisterType((*ListDiskTypesRequest)(nil), "yandex.cloud.compute.v1.ListDiskTypesRequest")
proto.RegisterType((*ListDiskTypesResponse)(nil), "yandex.cloud.compute.v1.ListDiskTypesResponse")
}
// 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
// DiskTypeServiceClient is the client API for DiskTypeService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DiskTypeServiceClient interface {
// Returns the information about specified disk type.
//
// To get the list of available disk types, make a [List] request.
Get(ctx context.Context, in *GetDiskTypeRequest, opts ...grpc.CallOption) (*DiskType, error)
// Retrieves the list of disk types for the specified folder.
List(ctx context.Context, in *ListDiskTypesRequest, opts ...grpc.CallOption) (*ListDiskTypesResponse, error)
}
type diskTypeServiceClient struct {
cc *grpc.ClientConn
}
func NewDiskTypeServiceClient(cc *grpc.ClientConn) DiskTypeServiceClient {
return &diskTypeServiceClient{cc}
}
func (c *diskTypeServiceClient) Get(ctx context.Context, in *GetDiskTypeRequest, opts ...grpc.CallOption) (*DiskType, error) {
out := new(DiskType)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.DiskTypeService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *diskTypeServiceClient) List(ctx context.Context, in *ListDiskTypesRequest, opts ...grpc.CallOption) (*ListDiskTypesResponse, error) {
out := new(ListDiskTypesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.DiskTypeService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DiskTypeServiceServer is the server API for DiskTypeService service.
type DiskTypeServiceServer interface {
// Returns the information about specified disk type.
//
// To get the list of available disk types, make a [List] request.
Get(context.Context, *GetDiskTypeRequest) (*DiskType, error)
// Retrieves the list of disk types for the specified folder.
List(context.Context, *ListDiskTypesRequest) (*ListDiskTypesResponse, error)
}
func RegisterDiskTypeServiceServer(s *grpc.Server, srv DiskTypeServiceServer) {
s.RegisterService(&_DiskTypeService_serviceDesc, srv)
}
func _DiskTypeService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDiskTypeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DiskTypeServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.DiskTypeService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiskTypeServiceServer).Get(ctx, req.(*GetDiskTypeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DiskTypeService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDiskTypesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DiskTypeServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.DiskTypeService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiskTypeServiceServer).List(ctx, req.(*ListDiskTypesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DiskTypeService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.DiskTypeService",
HandlerType: (*DiskTypeServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DiskTypeService_Get_Handler,
},
{
MethodName: "List",
Handler: _DiskTypeService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/disk_type_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk_type_service.proto", fileDescriptor_disk_type_service_42656155dbce67c7)
}
var fileDescriptor_disk_type_service_42656155dbce67c7 = []byte{
// 427 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0xaa, 0xd3, 0x40,
0x14, 0xc6, 0x49, 0x7b, 0xbd, 0x98, 0xa3, 0x72, 0x61, 0xf0, 0x72, 0x4b, 0xf0, 0xc2, 0x35, 0x48,
0x5b, 0xd0, 0x66, 0x9a, 0xba, 0xb4, 0x82, 0x54, 0xa5, 0x08, 0x2e, 0x24, 0xed, 0xca, 0x4d, 0x48,
0x9b, 0x43, 0x1c, 0x5a, 0x67, 0x62, 0x67, 0x12, 0xda, 0x8a, 0x0b, 0xff, 0xac, 0xdc, 0xba, 0xf7,
0x75, 0xea, 0xde, 0x57, 0x70, 0xe1, 0x33, 0xb8, 0x92, 0x4c, 0x92, 0xaa, 0xb5, 0xa1, 0x77, 0x17,
0x72, 0xbe, 0xef, 0x9c, 0xdf, 0x9c, 0x6f, 0x06, 0xe8, 0x2a, 0xe0, 0x21, 0x2e, 0xe9, 0x74, 0x2e,
0x92, 0x90, 0x4e, 0xc5, 0xeb, 0x38, 0x51, 0x48, 0x53, 0x97, 0x86, 0x4c, 0xce, 0x7c, 0xb5, 0x8a,
0xd1, 0x97, 0xb8, 0x48, 0xd9, 0x14, 0x9d, 0x78, 0x21, 0x94, 0x20, 0x67, 0xb9, 0xc1, 0xd1, 0x06,
0xa7, 0x30, 0x38, 0xa9, 0x6b, 0xdd, 0x8a, 0x84, 0x88, 0xe6, 0x48, 0x83, 0x98, 0xd1, 0x80, 0x73,
0xa1, 0x02, 0xc5, 0x04, 0x97, 0xb9, 0xcd, 0x6a, 0x1d, 0x9c, 0x53, 0x08, 0xcf, 0xff, 0x11, 0xa6,
0xc1, 0x9c, 0x85, 0xba, 0x51, 0x5e, 0xb6, 0xfb, 0x40, 0x86, 0xa8, 0x9e, 0x30, 0x39, 0x1b, 0xaf,
0x62, 0xf4, 0xf0, 0x4d, 0x82, 0x52, 0x91, 0x26, 0x5c, 0xff, 0xc3, 0xcb, 0xc2, 0x86, 0x71, 0x61,
0xb4, 0xcd, 0xc1, 0xd1, 0xcf, 0x8d, 0x6b, 0x78, 0x10, 0x16, 0xe2, 0x67, 0xa1, 0xcd, 0xe0, 0xe6,
0x73, 0x26, 0xb7, 0x76, 0x59, 0xfa, 0x5b, 0x60, 0xc6, 0x41, 0x84, 0xbe, 0x64, 0x6b, 0xd4, 0xe6,
0xfa, 0x00, 0x7e, 0x6d, 0xdc, 0xe3, 0xfe, 0x43, 0xb7, 0xdb, 0xed, 0x7a, 0x57, 0xb3, 0xe2, 0x88,
0xad, 0x91, 0xb4, 0x01, 0xb4, 0x50, 0x89, 0x19, 0xf2, 0x46, 0x4d, 0x8f, 0x31, 0x3f, 0x7f, 0x73,
0xaf, 0x68, 0xa5, 0xa7, 0xbb, 0x8c, 0xb3, 0x9a, 0xfd, 0xde, 0x80, 0xd3, 0x9d, 0x59, 0x32, 0x16,
0x5c, 0x22, 0x79, 0x04, 0xb0, 0x85, 0x95, 0x0d, 0xe3, 0xa2, 0xde, 0xbe, 0xd6, 0xbb, 0xed, 0x54,
0xac, 0xd5, 0xd9, 0x1e, 0xd5, 0x2c, 0xcf, 0x21, 0x49, 0x13, 0x4e, 0x38, 0x2e, 0x95, 0xbf, 0x8b,
0xe2, 0xdd, 0xc8, 0x7e, 0xbf, 0x28, 0x19, 0x7a, 0x5f, 0x6b, 0x70, 0x52, 0xfa, 0x47, 0x79, 0x8a,
0xe4, 0xa3, 0x01, 0xf5, 0x21, 0x2a, 0x72, 0xb7, 0x72, 0xe2, 0xff, 0xfb, 0xb5, 0x0e, 0xe3, 0xd9,
0xf7, 0x3e, 0x7c, 0xff, 0xf1, 0xa5, 0xd6, 0x24, 0x77, 0x76, 0xc3, 0xd5, 0xc8, 0xf4, 0xed, 0xdf,
0xf9, 0xbc, 0x23, 0x9f, 0x0c, 0x38, 0xca, 0xb6, 0x43, 0x3a, 0x95, 0x9d, 0xf7, 0x05, 0x65, 0x39,
0x97, 0x95, 0xe7, 0xbb, 0xb6, 0xcf, 0x35, 0xd5, 0x19, 0x39, 0xdd, 0x4b, 0x35, 0x78, 0xfa, 0xf2,
0x71, 0xc4, 0xd4, 0xab, 0x64, 0x92, 0x75, 0x2a, 0x9e, 0x42, 0x27, 0xbf, 0x79, 0x91, 0xe8, 0x44,
0xc8, 0xf5, 0xa5, 0xab, 0x7a, 0x23, 0x0f, 0x8a, 0xcf, 0xc9, 0xb1, 0x96, 0xdd, 0xff, 0x1d, 0x00,
0x00, 0xff, 0xff, 0xf1, 0x82, 0x37, 0x5b, 0x4d, 0x03, 0x00, 0x00,
}

323
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/image.pb.go generated vendored Normal file
View File

@ -0,0 +1,323 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/image.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Image_Status int32
const (
Image_STATUS_UNSPECIFIED Image_Status = 0
// Image is being created.
Image_CREATING Image_Status = 1
// Image is ready to use.
Image_READY Image_Status = 2
// Image encountered a problem and cannot operate.
Image_ERROR Image_Status = 3
// Image is being deleted.
Image_DELETING Image_Status = 4
)
var Image_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Image_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Image_Status) String() string {
return proto.EnumName(Image_Status_name, int32(x))
}
func (Image_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_image_50f442d51c07b7d7, []int{0, 0}
}
type Os_Type int32
const (
Os_TYPE_UNSPECIFIED Os_Type = 0
// Linux operating system.
Os_LINUX Os_Type = 1
// Windows operating system.
Os_WINDOWS Os_Type = 2
)
var Os_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "LINUX",
2: "WINDOWS",
}
var Os_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"LINUX": 1,
"WINDOWS": 2,
}
func (x Os_Type) String() string {
return proto.EnumName(Os_Type_name, int32(x))
}
func (Os_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_image_50f442d51c07b7d7, []int{1, 0}
}
// An Image resource.
type Image struct {
// ID of the image.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the image belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the image. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the image. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The name of the image family to which this image belongs.
//
// You can get the most recent image from a family by using
// the [yandex.cloud.compute.v1.ImageService.GetLatestByFamily] request
// and create the disk from this image.
Family string `protobuf:"bytes,7,opt,name=family,proto3" json:"family,omitempty"`
// The size of the image, specified in bytes.
StorageSize int64 `protobuf:"varint,8,opt,name=storage_size,json=storageSize,proto3" json:"storage_size,omitempty"`
// Minimum size of the disk which will be created from this image.
MinDiskSize int64 `protobuf:"varint,9,opt,name=min_disk_size,json=minDiskSize,proto3" json:"min_disk_size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,10,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the image.
Status Image_Status `protobuf:"varint,11,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Image_Status" json:"status,omitempty"`
// Operating system that is contained in the image.
Os *Os `protobuf:"bytes,12,opt,name=os,proto3" json:"os,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Image) Reset() { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage() {}
func (*Image) Descriptor() ([]byte, []int) {
return fileDescriptor_image_50f442d51c07b7d7, []int{0}
}
func (m *Image) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Image.Unmarshal(m, b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Image.Marshal(b, m, deterministic)
}
func (dst *Image) XXX_Merge(src proto.Message) {
xxx_messageInfo_Image.Merge(dst, src)
}
func (m *Image) XXX_Size() int {
return xxx_messageInfo_Image.Size(m)
}
func (m *Image) XXX_DiscardUnknown() {
xxx_messageInfo_Image.DiscardUnknown(m)
}
var xxx_messageInfo_Image proto.InternalMessageInfo
func (m *Image) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Image) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Image) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Image) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Image) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Image) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Image) GetFamily() string {
if m != nil {
return m.Family
}
return ""
}
func (m *Image) GetStorageSize() int64 {
if m != nil {
return m.StorageSize
}
return 0
}
func (m *Image) GetMinDiskSize() int64 {
if m != nil {
return m.MinDiskSize
}
return 0
}
func (m *Image) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Image) GetStatus() Image_Status {
if m != nil {
return m.Status
}
return Image_STATUS_UNSPECIFIED
}
func (m *Image) GetOs() *Os {
if m != nil {
return m.Os
}
return nil
}
type Os struct {
// Operating system type.
Type Os_Type `protobuf:"varint,1,opt,name=type,proto3,enum=yandex.cloud.compute.v1.Os_Type" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Os) Reset() { *m = Os{} }
func (m *Os) String() string { return proto.CompactTextString(m) }
func (*Os) ProtoMessage() {}
func (*Os) Descriptor() ([]byte, []int) {
return fileDescriptor_image_50f442d51c07b7d7, []int{1}
}
func (m *Os) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Os.Unmarshal(m, b)
}
func (m *Os) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Os.Marshal(b, m, deterministic)
}
func (dst *Os) XXX_Merge(src proto.Message) {
xxx_messageInfo_Os.Merge(dst, src)
}
func (m *Os) XXX_Size() int {
return xxx_messageInfo_Os.Size(m)
}
func (m *Os) XXX_DiscardUnknown() {
xxx_messageInfo_Os.DiscardUnknown(m)
}
var xxx_messageInfo_Os proto.InternalMessageInfo
func (m *Os) GetType() Os_Type {
if m != nil {
return m.Type
}
return Os_TYPE_UNSPECIFIED
}
func init() {
proto.RegisterType((*Image)(nil), "yandex.cloud.compute.v1.Image")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Image.LabelsEntry")
proto.RegisterType((*Os)(nil), "yandex.cloud.compute.v1.Os")
proto.RegisterEnum("yandex.cloud.compute.v1.Image_Status", Image_Status_name, Image_Status_value)
proto.RegisterEnum("yandex.cloud.compute.v1.Os_Type", Os_Type_name, Os_Type_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/image.proto", fileDescriptor_image_50f442d51c07b7d7)
}
var fileDescriptor_image_50f442d51c07b7d7 = []byte{
// 555 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xdf, 0x6b, 0x9c, 0x40,
0x10, 0xc7, 0xab, 0xf7, 0x23, 0x71, 0x4c, 0x83, 0x2c, 0x21, 0x95, 0xe4, 0x21, 0xf6, 0x4a, 0xe1,
0x68, 0x89, 0x92, 0x6b, 0x1e, 0x9a, 0x96, 0x3e, 0x5c, 0x72, 0xb6, 0x08, 0xe1, 0x2e, 0xec, 0x19,
0xd2, 0xf4, 0x45, 0xbc, 0xdb, 0x8d, 0x5d, 0xa2, 0xae, 0xb8, 0x6b, 0xa8, 0xf9, 0x7b, 0xfb, 0x87,
0x14, 0x57, 0x03, 0xa1, 0x70, 0xed, 0xdb, 0xcc, 0xd7, 0xcf, 0xcc, 0x77, 0x67, 0xd7, 0x81, 0x37,
0x75, 0x9c, 0x13, 0xfa, 0xcb, 0x5b, 0xa7, 0xbc, 0x22, 0xde, 0x9a, 0x67, 0x45, 0x25, 0xa9, 0xf7,
0x70, 0xe2, 0xb1, 0x2c, 0x4e, 0xa8, 0x5b, 0x94, 0x5c, 0x72, 0xf4, 0xaa, 0x85, 0x5c, 0x05, 0xb9,
0x1d, 0xe4, 0x3e, 0x9c, 0x1c, 0x1c, 0x25, 0x9c, 0x27, 0x29, 0xf5, 0x14, 0xb6, 0xaa, 0xee, 0x3c,
0xc9, 0x32, 0x2a, 0x64, 0x9c, 0x15, 0x6d, 0xe5, 0xe8, 0x77, 0x1f, 0x06, 0x41, 0xd3, 0x09, 0xed,
0x82, 0xce, 0x88, 0xad, 0x39, 0xda, 0xd8, 0xc0, 0x3a, 0x23, 0xe8, 0x10, 0x8c, 0x3b, 0x9e, 0x12,
0x5a, 0x46, 0x8c, 0xd8, 0xba, 0x92, 0xb7, 0x5b, 0x21, 0x20, 0xe8, 0x0c, 0x60, 0x5d, 0xd2, 0x58,
0x52, 0x12, 0xc5, 0xd2, 0xee, 0x39, 0xda, 0xd8, 0x9c, 0x1c, 0xb8, 0xad, 0x99, 0xfb, 0x64, 0xe6,
0x86, 0x4f, 0x66, 0xd8, 0xe8, 0xe8, 0xa9, 0x44, 0x08, 0xfa, 0x79, 0x9c, 0x51, 0xbb, 0xaf, 0x5a,
0xaa, 0x18, 0x39, 0x60, 0x12, 0x2a, 0xd6, 0x25, 0x2b, 0x24, 0xe3, 0xb9, 0x3d, 0x50, 0x9f, 0x9e,
0x4b, 0xe8, 0x1c, 0x86, 0x69, 0xbc, 0xa2, 0xa9, 0xb0, 0x87, 0x4e, 0x6f, 0x6c, 0x4e, 0xde, 0xb9,
0x1b, 0x46, 0x76, 0xd5, 0x34, 0xee, 0xa5, 0x82, 0xfd, 0x5c, 0x96, 0x35, 0xee, 0x2a, 0xd1, 0x3e,
0x0c, 0xef, 0xe2, 0x8c, 0xa5, 0xb5, 0xbd, 0xa5, 0x0c, 0xba, 0x0c, 0xbd, 0x86, 0x1d, 0x21, 0x79,
0x19, 0x27, 0x34, 0x12, 0xec, 0x91, 0xda, 0xdb, 0x8e, 0x36, 0xee, 0x61, 0xb3, 0xd3, 0x96, 0xec,
0x91, 0xa2, 0x11, 0xbc, 0xcc, 0x58, 0x1e, 0x11, 0x26, 0xee, 0x5b, 0xc6, 0x68, 0x99, 0x8c, 0xe5,
0x33, 0x26, 0xee, 0x15, 0x73, 0x04, 0x66, 0x51, 0x72, 0x52, 0xad, 0x65, 0xc4, 0x88, 0xb0, 0xc1,
0xe9, 0x8d, 0x0d, 0x0c, 0x9d, 0x14, 0x10, 0x81, 0xbe, 0xc0, 0x50, 0xc8, 0x58, 0x56, 0xc2, 0x36,
0x1d, 0x6d, 0xbc, 0x3b, 0x79, 0xfb, 0x9f, 0x19, 0x96, 0x0a, 0xc6, 0x5d, 0x11, 0x7a, 0x0f, 0x3a,
0x17, 0xf6, 0x8e, 0xba, 0xeb, 0xc3, 0x8d, 0xa5, 0x0b, 0x81, 0x75, 0x2e, 0x0e, 0xce, 0xc0, 0x7c,
0x76, 0x05, 0xc8, 0x82, 0xde, 0x3d, 0xad, 0xbb, 0xd7, 0x6d, 0x42, 0xb4, 0x07, 0x83, 0x87, 0x38,
0xad, 0x68, 0xf7, 0xb4, 0x6d, 0xf2, 0x49, 0xff, 0xa8, 0x8d, 0x30, 0x0c, 0x5b, 0x67, 0xb4, 0x0f,
0x68, 0x19, 0x4e, 0xc3, 0xeb, 0x65, 0x74, 0x3d, 0x5f, 0x5e, 0xf9, 0x17, 0xc1, 0xd7, 0xc0, 0x9f,
0x59, 0x2f, 0xd0, 0x0e, 0x6c, 0x5f, 0x60, 0x7f, 0x1a, 0x06, 0xf3, 0x6f, 0x96, 0x86, 0x0c, 0x18,
0x60, 0x7f, 0x3a, 0xbb, 0xb5, 0xf4, 0x26, 0xf4, 0x31, 0x5e, 0x60, 0xab, 0xd7, 0x30, 0x33, 0xff,
0xd2, 0x57, 0x4c, 0x7f, 0x54, 0x80, 0xbe, 0x10, 0xe8, 0x14, 0xfa, 0xb2, 0x2e, 0xa8, 0x3a, 0xc6,
0xee, 0xc4, 0xf9, 0xc7, 0x0c, 0x6e, 0x58, 0x17, 0x14, 0x2b, 0x7a, 0x74, 0x0a, 0xfd, 0x26, 0x43,
0x7b, 0x60, 0x85, 0xb7, 0x57, 0xfe, 0x5f, 0x67, 0x31, 0x60, 0x70, 0x19, 0xcc, 0xaf, 0xbf, 0x5b,
0x1a, 0x32, 0x61, 0xeb, 0x26, 0x98, 0xcf, 0x16, 0x37, 0x4b, 0x4b, 0x3f, 0xf7, 0x7f, 0x5c, 0x24,
0x4c, 0xfe, 0xac, 0x56, 0x4d, 0x63, 0xaf, 0x75, 0x3a, 0x6e, 0x97, 0x28, 0xe1, 0xc7, 0x09, 0xcd,
0xd5, 0x5f, 0xea, 0x6d, 0xd8, 0xae, 0xcf, 0x5d, 0xb8, 0x1a, 0x2a, 0xec, 0xc3, 0x9f, 0x00, 0x00,
0x00, 0xff, 0xff, 0xee, 0xdc, 0xf1, 0x6f, 0x87, 0x03, 0x00, 0x00,
}

1278
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/image_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

752
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instance.pb.go generated vendored Normal file
View File

@ -0,0 +1,752 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/instance.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type IpVersion int32
const (
IpVersion_IP_VERSION_UNSPECIFIED IpVersion = 0
// IPv4 address, for example 192.0.2.235.
IpVersion_IPV4 IpVersion = 1
// IPv6 address. Not available yet.
IpVersion_IPV6 IpVersion = 2
)
var IpVersion_name = map[int32]string{
0: "IP_VERSION_UNSPECIFIED",
1: "IPV4",
2: "IPV6",
}
var IpVersion_value = map[string]int32{
"IP_VERSION_UNSPECIFIED": 0,
"IPV4": 1,
"IPV6": 2,
}
func (x IpVersion) String() string {
return proto.EnumName(IpVersion_name, int32(x))
}
func (IpVersion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{0}
}
type Instance_Status int32
const (
Instance_STATUS_UNSPECIFIED Instance_Status = 0
// Instance is waiting for resources to be allocated.
Instance_PROVISIONING Instance_Status = 1
// Instance is running normally.
Instance_RUNNING Instance_Status = 2
// Instance is being stopped.
Instance_STOPPING Instance_Status = 3
// Instance stopped.
Instance_STOPPED Instance_Status = 4
// Instance is being started.
Instance_STARTING Instance_Status = 5
// Instance is being restarted.
Instance_RESTARTING Instance_Status = 6
// Instance is being updated.
Instance_UPDATING Instance_Status = 7
// Instance encountered a problem and cannot operate.
Instance_ERROR Instance_Status = 8
// Instance crashed and will be restarted automatically.
Instance_CRASHED Instance_Status = 9
// Instance is being deleted.
Instance_DELETING Instance_Status = 10
)
var Instance_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "PROVISIONING",
2: "RUNNING",
3: "STOPPING",
4: "STOPPED",
5: "STARTING",
6: "RESTARTING",
7: "UPDATING",
8: "ERROR",
9: "CRASHED",
10: "DELETING",
}
var Instance_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"PROVISIONING": 1,
"RUNNING": 2,
"STOPPING": 3,
"STOPPED": 4,
"STARTING": 5,
"RESTARTING": 6,
"UPDATING": 7,
"ERROR": 8,
"CRASHED": 9,
"DELETING": 10,
}
func (x Instance_Status) String() string {
return proto.EnumName(Instance_Status_name, int32(x))
}
func (Instance_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{0, 0}
}
type AttachedDisk_Mode int32
const (
AttachedDisk_MODE_UNSPECIFIED AttachedDisk_Mode = 0
// Read-only access.
AttachedDisk_READ_ONLY AttachedDisk_Mode = 1
// Read/Write access.
AttachedDisk_READ_WRITE AttachedDisk_Mode = 2
)
var AttachedDisk_Mode_name = map[int32]string{
0: "MODE_UNSPECIFIED",
1: "READ_ONLY",
2: "READ_WRITE",
}
var AttachedDisk_Mode_value = map[string]int32{
"MODE_UNSPECIFIED": 0,
"READ_ONLY": 1,
"READ_WRITE": 2,
}
func (x AttachedDisk_Mode) String() string {
return proto.EnumName(AttachedDisk_Mode_name, int32(x))
}
func (AttachedDisk_Mode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{2, 0}
}
// An Instance resource. For more information, see [Instances](/docs/compute/concepts/vm).
type Instance struct {
// ID of the instance.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the instance belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the instance. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the instance. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the availability zone where the instance resides.
ZoneId string `protobuf:"bytes,7,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// ID of the hardware platform configuration for the instance.
PlatformId string `protobuf:"bytes,8,opt,name=platform_id,json=platformId,proto3" json:"platform_id,omitempty"`
// Computing resources of the instance such as the amount of memory and number of cores.
Resources *Resources `protobuf:"bytes,9,opt,name=resources,proto3" json:"resources,omitempty"`
// Status of the instance.
Status Instance_Status `protobuf:"varint,10,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Instance_Status" json:"status,omitempty"`
// The metadata `key:value` pairs assigned to this instance. This includes custom metadata and predefined keys.
//
// For example, you may use the metadata in order to provide your public SSH key to the instance.
// For more information, see [Metadata](/docs/compute/concepts/vm-metadata).
Metadata map[string]string `protobuf:"bytes,11,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Boot disk that is attached to the instance.
BootDisk *AttachedDisk `protobuf:"bytes,12,opt,name=boot_disk,json=bootDisk,proto3" json:"boot_disk,omitempty"`
// Array of secondary disks that are attached to the instance.
SecondaryDisks []*AttachedDisk `protobuf:"bytes,13,rep,name=secondary_disks,json=secondaryDisks,proto3" json:"secondary_disks,omitempty"`
// Array of network interfaces that are attached to the instance.
NetworkInterfaces []*NetworkInterface `protobuf:"bytes,14,rep,name=network_interfaces,json=networkInterfaces,proto3" json:"network_interfaces,omitempty"`
// A domain name of the instance. FQDN is defined by the server
// in the format `<hostname>.<region_id>.internal` when the instance is created.
// If the hostname were not specified when the instance was created, FQDN would be `<id>.auto.internal`.
Fqdn string `protobuf:"bytes,16,opt,name=fqdn,proto3" json:"fqdn,omitempty"`
// Scheduling policy configuration.
SchedulingPolicy *SchedulingPolicy `protobuf:"bytes,17,opt,name=scheduling_policy,json=schedulingPolicy,proto3" json:"scheduling_policy,omitempty"`
ServiceAccountId string `protobuf:"bytes,18,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Instance) Reset() { *m = Instance{} }
func (m *Instance) String() string { return proto.CompactTextString(m) }
func (*Instance) ProtoMessage() {}
func (*Instance) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{0}
}
func (m *Instance) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Instance.Unmarshal(m, b)
}
func (m *Instance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Instance.Marshal(b, m, deterministic)
}
func (dst *Instance) XXX_Merge(src proto.Message) {
xxx_messageInfo_Instance.Merge(dst, src)
}
func (m *Instance) XXX_Size() int {
return xxx_messageInfo_Instance.Size(m)
}
func (m *Instance) XXX_DiscardUnknown() {
xxx_messageInfo_Instance.DiscardUnknown(m)
}
var xxx_messageInfo_Instance proto.InternalMessageInfo
func (m *Instance) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Instance) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Instance) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Instance) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Instance) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Instance) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Instance) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Instance) GetPlatformId() string {
if m != nil {
return m.PlatformId
}
return ""
}
func (m *Instance) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Instance) GetStatus() Instance_Status {
if m != nil {
return m.Status
}
return Instance_STATUS_UNSPECIFIED
}
func (m *Instance) GetMetadata() map[string]string {
if m != nil {
return m.Metadata
}
return nil
}
func (m *Instance) GetBootDisk() *AttachedDisk {
if m != nil {
return m.BootDisk
}
return nil
}
func (m *Instance) GetSecondaryDisks() []*AttachedDisk {
if m != nil {
return m.SecondaryDisks
}
return nil
}
func (m *Instance) GetNetworkInterfaces() []*NetworkInterface {
if m != nil {
return m.NetworkInterfaces
}
return nil
}
func (m *Instance) GetFqdn() string {
if m != nil {
return m.Fqdn
}
return ""
}
func (m *Instance) GetSchedulingPolicy() *SchedulingPolicy {
if m != nil {
return m.SchedulingPolicy
}
return nil
}
func (m *Instance) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
type Resources struct {
// The amount of memory available to the instance, specified in bytes.
Memory int64 `protobuf:"varint,1,opt,name=memory,proto3" json:"memory,omitempty"`
// The number of cores available to the instance.
Cores int64 `protobuf:"varint,2,opt,name=cores,proto3" json:"cores,omitempty"`
// Baseline level of CPU performance with the ability to burst performance above that baseline level.
// This field sets baseline performance for each core.
CoreFraction int64 `protobuf:"varint,3,opt,name=core_fraction,json=coreFraction,proto3" json:"core_fraction,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Resources) Reset() { *m = Resources{} }
func (m *Resources) String() string { return proto.CompactTextString(m) }
func (*Resources) ProtoMessage() {}
func (*Resources) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{1}
}
func (m *Resources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Resources.Unmarshal(m, b)
}
func (m *Resources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Resources.Marshal(b, m, deterministic)
}
func (dst *Resources) XXX_Merge(src proto.Message) {
xxx_messageInfo_Resources.Merge(dst, src)
}
func (m *Resources) XXX_Size() int {
return xxx_messageInfo_Resources.Size(m)
}
func (m *Resources) XXX_DiscardUnknown() {
xxx_messageInfo_Resources.DiscardUnknown(m)
}
var xxx_messageInfo_Resources proto.InternalMessageInfo
func (m *Resources) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func (m *Resources) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *Resources) GetCoreFraction() int64 {
if m != nil {
return m.CoreFraction
}
return 0
}
type AttachedDisk struct {
// Access mode to the Disk resource.
Mode AttachedDisk_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=yandex.cloud.compute.v1.AttachedDisk_Mode" json:"mode,omitempty"`
// Serial number that is reflected into the /dev/disk/by-id/ tree
// of a Linux operating system running within the instance.
//
// This value can be used to reference the device for mounting, resizing, and so on, from within the instance.
DeviceName string `protobuf:"bytes,2,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
// Specifies whether the disk will be auto-deleted when the instance is deleted.
AutoDelete bool `protobuf:"varint,3,opt,name=auto_delete,json=autoDelete,proto3" json:"auto_delete,omitempty"`
// ID of the disk that is attached to the instance.
DiskId string `protobuf:"bytes,4,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AttachedDisk) Reset() { *m = AttachedDisk{} }
func (m *AttachedDisk) String() string { return proto.CompactTextString(m) }
func (*AttachedDisk) ProtoMessage() {}
func (*AttachedDisk) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{2}
}
func (m *AttachedDisk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AttachedDisk.Unmarshal(m, b)
}
func (m *AttachedDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AttachedDisk.Marshal(b, m, deterministic)
}
func (dst *AttachedDisk) XXX_Merge(src proto.Message) {
xxx_messageInfo_AttachedDisk.Merge(dst, src)
}
func (m *AttachedDisk) XXX_Size() int {
return xxx_messageInfo_AttachedDisk.Size(m)
}
func (m *AttachedDisk) XXX_DiscardUnknown() {
xxx_messageInfo_AttachedDisk.DiscardUnknown(m)
}
var xxx_messageInfo_AttachedDisk proto.InternalMessageInfo
func (m *AttachedDisk) GetMode() AttachedDisk_Mode {
if m != nil {
return m.Mode
}
return AttachedDisk_MODE_UNSPECIFIED
}
func (m *AttachedDisk) GetDeviceName() string {
if m != nil {
return m.DeviceName
}
return ""
}
func (m *AttachedDisk) GetAutoDelete() bool {
if m != nil {
return m.AutoDelete
}
return false
}
func (m *AttachedDisk) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
type NetworkInterface struct {
// The index of the network interface, generated by the server, 0,1,2... etc.
// Currently only one network interface is supported per instance.
Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
// MAC address that is assigned to the network interface.
MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
// ID of the subnet.
SubnetId string `protobuf:"bytes,3,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// Primary IPv4 address that is assigned to the instance for this network interface.
PrimaryV4Address *PrimaryAddress `protobuf:"bytes,4,opt,name=primary_v4_address,json=primaryV4Address,proto3" json:"primary_v4_address,omitempty"`
// Primary IPv6 address that is assigned to the instance for this network interface. IPv6 not available yet.
PrimaryV6Address *PrimaryAddress `protobuf:"bytes,5,opt,name=primary_v6_address,json=primaryV6Address,proto3" json:"primary_v6_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NetworkInterface) Reset() { *m = NetworkInterface{} }
func (m *NetworkInterface) String() string { return proto.CompactTextString(m) }
func (*NetworkInterface) ProtoMessage() {}
func (*NetworkInterface) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{3}
}
func (m *NetworkInterface) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NetworkInterface.Unmarshal(m, b)
}
func (m *NetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NetworkInterface.Marshal(b, m, deterministic)
}
func (dst *NetworkInterface) XXX_Merge(src proto.Message) {
xxx_messageInfo_NetworkInterface.Merge(dst, src)
}
func (m *NetworkInterface) XXX_Size() int {
return xxx_messageInfo_NetworkInterface.Size(m)
}
func (m *NetworkInterface) XXX_DiscardUnknown() {
xxx_messageInfo_NetworkInterface.DiscardUnknown(m)
}
var xxx_messageInfo_NetworkInterface proto.InternalMessageInfo
func (m *NetworkInterface) GetIndex() string {
if m != nil {
return m.Index
}
return ""
}
func (m *NetworkInterface) GetMacAddress() string {
if m != nil {
return m.MacAddress
}
return ""
}
func (m *NetworkInterface) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *NetworkInterface) GetPrimaryV4Address() *PrimaryAddress {
if m != nil {
return m.PrimaryV4Address
}
return nil
}
func (m *NetworkInterface) GetPrimaryV6Address() *PrimaryAddress {
if m != nil {
return m.PrimaryV6Address
}
return nil
}
type PrimaryAddress struct {
// An IPv4 internal network address that is assigned to the instance for this network interface.
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// One-to-one NAT configuration. If missing, NAT has not been set up.
OneToOneNat *OneToOneNat `protobuf:"bytes,2,opt,name=one_to_one_nat,json=oneToOneNat,proto3" json:"one_to_one_nat,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PrimaryAddress) Reset() { *m = PrimaryAddress{} }
func (m *PrimaryAddress) String() string { return proto.CompactTextString(m) }
func (*PrimaryAddress) ProtoMessage() {}
func (*PrimaryAddress) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{4}
}
func (m *PrimaryAddress) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PrimaryAddress.Unmarshal(m, b)
}
func (m *PrimaryAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PrimaryAddress.Marshal(b, m, deterministic)
}
func (dst *PrimaryAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_PrimaryAddress.Merge(dst, src)
}
func (m *PrimaryAddress) XXX_Size() int {
return xxx_messageInfo_PrimaryAddress.Size(m)
}
func (m *PrimaryAddress) XXX_DiscardUnknown() {
xxx_messageInfo_PrimaryAddress.DiscardUnknown(m)
}
var xxx_messageInfo_PrimaryAddress proto.InternalMessageInfo
func (m *PrimaryAddress) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *PrimaryAddress) GetOneToOneNat() *OneToOneNat {
if m != nil {
return m.OneToOneNat
}
return nil
}
type OneToOneNat struct {
// An external IP address associated with this instance.
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// IP version for the external IP address.
IpVersion IpVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=yandex.cloud.compute.v1.IpVersion" json:"ip_version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *OneToOneNat) Reset() { *m = OneToOneNat{} }
func (m *OneToOneNat) String() string { return proto.CompactTextString(m) }
func (*OneToOneNat) ProtoMessage() {}
func (*OneToOneNat) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{5}
}
func (m *OneToOneNat) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OneToOneNat.Unmarshal(m, b)
}
func (m *OneToOneNat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_OneToOneNat.Marshal(b, m, deterministic)
}
func (dst *OneToOneNat) XXX_Merge(src proto.Message) {
xxx_messageInfo_OneToOneNat.Merge(dst, src)
}
func (m *OneToOneNat) XXX_Size() int {
return xxx_messageInfo_OneToOneNat.Size(m)
}
func (m *OneToOneNat) XXX_DiscardUnknown() {
xxx_messageInfo_OneToOneNat.DiscardUnknown(m)
}
var xxx_messageInfo_OneToOneNat proto.InternalMessageInfo
func (m *OneToOneNat) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *OneToOneNat) GetIpVersion() IpVersion {
if m != nil {
return m.IpVersion
}
return IpVersion_IP_VERSION_UNSPECIFIED
}
type SchedulingPolicy struct {
// True for short-lived compute instances. For more information, see [Preemptible VMs](/docs/compute/concepts/preemptible-vm).
Preemptible bool `protobuf:"varint,1,opt,name=preemptible,proto3" json:"preemptible,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SchedulingPolicy) Reset() { *m = SchedulingPolicy{} }
func (m *SchedulingPolicy) String() string { return proto.CompactTextString(m) }
func (*SchedulingPolicy) ProtoMessage() {}
func (*SchedulingPolicy) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_da800a4f3ac3c9a8, []int{6}
}
func (m *SchedulingPolicy) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SchedulingPolicy.Unmarshal(m, b)
}
func (m *SchedulingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SchedulingPolicy.Marshal(b, m, deterministic)
}
func (dst *SchedulingPolicy) XXX_Merge(src proto.Message) {
xxx_messageInfo_SchedulingPolicy.Merge(dst, src)
}
func (m *SchedulingPolicy) XXX_Size() int {
return xxx_messageInfo_SchedulingPolicy.Size(m)
}
func (m *SchedulingPolicy) XXX_DiscardUnknown() {
xxx_messageInfo_SchedulingPolicy.DiscardUnknown(m)
}
var xxx_messageInfo_SchedulingPolicy proto.InternalMessageInfo
func (m *SchedulingPolicy) GetPreemptible() bool {
if m != nil {
return m.Preemptible
}
return false
}
func init() {
proto.RegisterType((*Instance)(nil), "yandex.cloud.compute.v1.Instance")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Instance.LabelsEntry")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Instance.MetadataEntry")
proto.RegisterType((*Resources)(nil), "yandex.cloud.compute.v1.Resources")
proto.RegisterType((*AttachedDisk)(nil), "yandex.cloud.compute.v1.AttachedDisk")
proto.RegisterType((*NetworkInterface)(nil), "yandex.cloud.compute.v1.NetworkInterface")
proto.RegisterType((*PrimaryAddress)(nil), "yandex.cloud.compute.v1.PrimaryAddress")
proto.RegisterType((*OneToOneNat)(nil), "yandex.cloud.compute.v1.OneToOneNat")
proto.RegisterType((*SchedulingPolicy)(nil), "yandex.cloud.compute.v1.SchedulingPolicy")
proto.RegisterEnum("yandex.cloud.compute.v1.IpVersion", IpVersion_name, IpVersion_value)
proto.RegisterEnum("yandex.cloud.compute.v1.Instance_Status", Instance_Status_name, Instance_Status_value)
proto.RegisterEnum("yandex.cloud.compute.v1.AttachedDisk_Mode", AttachedDisk_Mode_name, AttachedDisk_Mode_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/instance.proto", fileDescriptor_instance_da800a4f3ac3c9a8)
}
var fileDescriptor_instance_da800a4f3ac3c9a8 = []byte{
// 1081 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xeb, 0x6e, 0xe2, 0xc6,
0x17, 0xff, 0x73, 0x09, 0xc1, 0x87, 0x84, 0xbf, 0x33, 0x5a, 0x65, 0xad, 0xf4, 0x43, 0x22, 0x7a,
0x4b, 0x57, 0x0d, 0x68, 0xd3, 0x28, 0xea, 0x36, 0x52, 0xb5, 0x6c, 0xf0, 0xb6, 0x56, 0x13, 0x40,
0x03, 0xa1, 0x97, 0x0f, 0xb5, 0x06, 0xcf, 0xc0, 0xba, 0xc1, 0x1e, 0xd7, 0x33, 0xa6, 0x4d, 0x9f,
0xa3, 0x2f, 0x51, 0xa9, 0xcf, 0xd5, 0xe7, 0xa8, 0x66, 0xc6, 0x66, 0x59, 0x24, 0xba, 0xdb, 0x7e,
0xe2, 0x5c, 0x7f, 0x67, 0xce, 0xe1, 0x37, 0x67, 0x0c, 0x1f, 0x3d, 0x90, 0x98, 0xb2, 0x5f, 0x3b,
0xc1, 0x82, 0x67, 0xb4, 0x13, 0xf0, 0x28, 0xc9, 0x24, 0xeb, 0x2c, 0x9f, 0x76, 0xc2, 0x58, 0x48,
0x12, 0x07, 0xac, 0x9d, 0xa4, 0x5c, 0x72, 0xf4, 0xd8, 0xc4, 0xb5, 0x75, 0x5c, 0x3b, 0x8f, 0x6b,
0x2f, 0x9f, 0x1e, 0x1d, 0xcf, 0x39, 0x9f, 0x2f, 0x58, 0x47, 0x87, 0x4d, 0xb3, 0x59, 0x47, 0x86,
0x11, 0x13, 0x92, 0x44, 0x89, 0xc9, 0x6c, 0xfd, 0x61, 0x41, 0xdd, 0xcb, 0xc1, 0x50, 0x13, 0xca,
0x21, 0x75, 0x4a, 0x27, 0xa5, 0x53, 0x0b, 0x97, 0x43, 0x8a, 0xde, 0x03, 0x6b, 0xc6, 0x17, 0x94,
0xa5, 0x7e, 0x48, 0x9d, 0xb2, 0x36, 0xd7, 0x8d, 0xc1, 0xa3, 0xe8, 0x19, 0x40, 0x90, 0x32, 0x22,
0x19, 0xf5, 0x89, 0x74, 0x2a, 0x27, 0xa5, 0xd3, 0xc6, 0xf9, 0x51, 0xdb, 0xd4, 0x6b, 0x17, 0xf5,
0xda, 0xe3, 0xa2, 0x1e, 0xb6, 0xf2, 0xe8, 0xae, 0x44, 0x08, 0xaa, 0x31, 0x89, 0x98, 0x53, 0xd5,
0x90, 0x5a, 0x46, 0x27, 0xd0, 0xa0, 0x4c, 0x04, 0x69, 0x98, 0xc8, 0x90, 0xc7, 0xce, 0x8e, 0x76,
0xad, 0x9b, 0x90, 0x0b, 0xb5, 0x05, 0x99, 0xb2, 0x85, 0x70, 0x6a, 0x27, 0x95, 0xd3, 0xc6, 0xf9,
0x59, 0x7b, 0x4b, 0xd7, 0xed, 0xa2, 0xa1, 0xf6, 0x8d, 0x8e, 0x77, 0x63, 0x99, 0x3e, 0xe0, 0x3c,
0x19, 0x3d, 0x86, 0xdd, 0xdf, 0x78, 0xcc, 0x54, 0x4b, 0xbb, 0xba, 0x48, 0x4d, 0xa9, 0x1e, 0x45,
0xc7, 0xd0, 0x48, 0x16, 0x44, 0xce, 0x78, 0x1a, 0x29, 0x67, 0x5d, 0x3b, 0xa1, 0x30, 0x79, 0x14,
0x3d, 0x07, 0x2b, 0x65, 0x82, 0x67, 0x69, 0xc0, 0x84, 0x63, 0xe9, 0x86, 0x5b, 0x5b, 0xcf, 0x80,
0x8b, 0x48, 0xfc, 0x3a, 0x09, 0x3d, 0x87, 0x9a, 0x90, 0x44, 0x66, 0xc2, 0x81, 0x93, 0xd2, 0x69,
0xf3, 0xfc, 0xf4, 0xed, 0x2d, 0x8c, 0x74, 0x3c, 0xce, 0xf3, 0xd0, 0x37, 0x50, 0x8f, 0x98, 0x24,
0x94, 0x48, 0xe2, 0x34, 0xf4, 0x18, 0x3a, 0x6f, 0xc7, 0xb8, 0xcd, 0x33, 0xcc, 0x20, 0x56, 0x00,
0xe8, 0x05, 0x58, 0x53, 0xce, 0xa5, 0x4f, 0x43, 0x71, 0xef, 0xec, 0xe9, 0x86, 0x3e, 0xdc, 0x8a,
0xd6, 0x95, 0x92, 0x04, 0xaf, 0x18, 0xed, 0x85, 0xe2, 0x1e, 0xd7, 0x55, 0x9e, 0x92, 0x50, 0x1f,
0xfe, 0x2f, 0x58, 0xc0, 0x63, 0x4a, 0xd2, 0x07, 0x0d, 0x24, 0x9c, 0x7d, 0x7d, 0xae, 0x77, 0x44,
0x6a, 0xae, 0xb2, 0x95, 0x2a, 0xd0, 0x77, 0x80, 0x62, 0x26, 0x7f, 0xe1, 0xe9, 0xbd, 0x1f, 0xc6,
0x92, 0xa5, 0x33, 0xa2, 0xa6, 0xdd, 0xd4, 0x90, 0x9f, 0x6c, 0x85, 0xec, 0x9b, 0x14, 0xaf, 0xc8,
0xc0, 0x07, 0xf1, 0x86, 0x45, 0x28, 0xd6, 0xcd, 0x7e, 0xa6, 0xb1, 0x63, 0x1b, 0xd6, 0x29, 0x19,
0x4d, 0xe0, 0x40, 0xa8, 0xa3, 0x64, 0x8b, 0x30, 0x9e, 0xfb, 0x09, 0x5f, 0x84, 0xc1, 0x83, 0x73,
0xa0, 0x27, 0xb1, 0xbd, 0xd8, 0x68, 0x95, 0x31, 0xd4, 0x09, 0xd8, 0x16, 0x1b, 0x16, 0xf4, 0x29,
0x20, 0xc1, 0xd2, 0x65, 0x18, 0x30, 0x9f, 0x04, 0x01, 0xcf, 0x62, 0xa9, 0x28, 0x85, 0x74, 0x65,
0x3b, 0xf7, 0x74, 0x8d, 0xc3, 0xa3, 0x47, 0xcf, 0xa0, 0xb1, 0xc6, 0x54, 0x64, 0x43, 0xe5, 0x9e,
0x3d, 0xe4, 0xf7, 0x50, 0x89, 0xe8, 0x11, 0xec, 0x2c, 0xc9, 0x22, 0x63, 0xf9, 0x25, 0x34, 0xca,
0x17, 0xe5, 0xcf, 0x4b, 0x47, 0x57, 0xb0, 0xff, 0xc6, 0xbf, 0xfb, 0x6f, 0x92, 0x5b, 0x7f, 0x96,
0xa0, 0x66, 0xf8, 0x85, 0x0e, 0x01, 0x8d, 0xc6, 0xdd, 0xf1, 0xdd, 0xc8, 0xbf, 0xeb, 0x8f, 0x86,
0xee, 0xb5, 0xf7, 0xd2, 0x73, 0x7b, 0xf6, 0xff, 0x90, 0x0d, 0x7b, 0x43, 0x3c, 0x98, 0x78, 0x23,
0x6f, 0xd0, 0xf7, 0xfa, 0x5f, 0xd9, 0x25, 0xd4, 0x80, 0x5d, 0x7c, 0xd7, 0xd7, 0x4a, 0x19, 0xed,
0x41, 0x7d, 0x34, 0x1e, 0x0c, 0x87, 0x4a, 0xab, 0x28, 0x97, 0xd6, 0xdc, 0x9e, 0x5d, 0x35, 0xae,
0x2e, 0x1e, 0x2b, 0xd7, 0x0e, 0x6a, 0x02, 0x60, 0x77, 0xa5, 0xd7, 0x94, 0xf7, 0x6e, 0xd8, 0xeb,
0x6a, 0x6d, 0x17, 0x59, 0xb0, 0xe3, 0x62, 0x3c, 0xc0, 0x76, 0x5d, 0x61, 0x5c, 0xe3, 0xee, 0xe8,
0x6b, 0xb7, 0x67, 0x5b, 0x2a, 0xaa, 0xe7, 0xde, 0xb8, 0x3a, 0x0a, 0x5a, 0x3f, 0x82, 0xb5, 0xba,
0x55, 0xe8, 0x10, 0x6a, 0x11, 0x8b, 0x78, 0x6a, 0x5a, 0xad, 0xe0, 0x5c, 0x53, 0xdd, 0x06, 0x3c,
0x65, 0x42, 0x77, 0x5b, 0xc1, 0x46, 0x41, 0xef, 0xc3, 0xbe, 0x12, 0xfc, 0x59, 0x4a, 0x02, 0xbd,
0x5f, 0x2a, 0xda, 0xbb, 0xa7, 0x8c, 0x2f, 0x73, 0x5b, 0xeb, 0xaf, 0x12, 0xec, 0xad, 0x73, 0x13,
0x7d, 0x09, 0xd5, 0x88, 0x53, 0xa6, 0x2b, 0x34, 0xcf, 0x9f, 0xbc, 0x13, 0xa1, 0xdb, 0xb7, 0x9c,
0x32, 0xac, 0xf3, 0xd4, 0x46, 0xa1, 0x4c, 0x93, 0x40, 0xaf, 0x3b, 0x33, 0x7f, 0x30, 0xa6, 0xbe,
0x5a, 0x7a, 0xc7, 0xd0, 0x20, 0x99, 0xe4, 0x3e, 0x65, 0x0b, 0x26, 0x99, 0x3e, 0x54, 0x1d, 0x83,
0x32, 0xf5, 0xb4, 0x45, 0x2d, 0x2b, 0x75, 0xa7, 0x14, 0x79, 0xcc, 0xb2, 0xac, 0x29, 0xd5, 0xa3,
0xad, 0x2b, 0xa8, 0xaa, 0x42, 0xe8, 0x11, 0xd8, 0xb7, 0x83, 0x9e, 0xbb, 0xf1, 0xaf, 0xed, 0x83,
0x85, 0xdd, 0x6e, 0xcf, 0x1f, 0xf4, 0x6f, 0xbe, 0xb7, 0x4b, 0x66, 0xf8, 0xdd, 0x9e, 0xff, 0x2d,
0xf6, 0xc6, 0xae, 0x5d, 0x6e, 0xfd, 0x5e, 0x06, 0x7b, 0xf3, 0xc6, 0xa8, 0xc1, 0x85, 0xaa, 0xbd,
0x9c, 0x3a, 0x46, 0x51, 0x27, 0x8c, 0x48, 0xe0, 0x13, 0x4a, 0x53, 0x26, 0x44, 0xd1, 0x42, 0x44,
0x82, 0xae, 0xb1, 0xa8, 0x37, 0x42, 0x64, 0xd3, 0x98, 0x69, 0x82, 0x57, 0xcc, 0x1b, 0x61, 0x0c,
0x1e, 0x45, 0x77, 0x80, 0x92, 0x34, 0x8c, 0xd4, 0x6a, 0x58, 0x5e, 0xac, 0x40, 0xaa, 0xfa, 0x7e,
0x7d, 0xbc, 0x75, 0x9c, 0x43, 0x93, 0x92, 0x57, 0xc0, 0x76, 0x0e, 0x31, 0xb9, 0x28, 0x6a, 0xae,
0xc3, 0x5e, 0xae, 0x60, 0x77, 0xfe, 0x23, 0xec, 0x65, 0x6e, 0x69, 0x65, 0xd0, 0x7c, 0x33, 0x06,
0x39, 0xb0, 0x5b, 0xa0, 0x9b, 0xa9, 0x14, 0x2a, 0xf2, 0xa0, 0xa9, 0x1e, 0x11, 0xc9, 0x7d, 0xf5,
0x13, 0x13, 0xa9, 0x47, 0xd3, 0x38, 0xff, 0x60, 0x6b, 0xf9, 0x41, 0xcc, 0xc6, 0x7c, 0x10, 0xb3,
0x3e, 0x91, 0xb8, 0xc1, 0x5f, 0x2b, 0xad, 0x9f, 0xa0, 0xb1, 0xe6, 0xfb, 0x87, 0x9a, 0x5d, 0x80,
0x30, 0xf1, 0x97, 0x2c, 0x15, 0x8a, 0xc1, 0x65, 0x4d, 0xca, 0xed, 0x0f, 0x90, 0x97, 0x4c, 0x4c,
0x24, 0xb6, 0xc2, 0x42, 0x6c, 0x5d, 0x80, 0xbd, 0xb9, 0xbd, 0xd4, 0xcb, 0x9b, 0xa4, 0x8c, 0x45,
0x89, 0x0c, 0xa7, 0x0b, 0x43, 0xf6, 0x3a, 0x5e, 0x37, 0x3d, 0xb9, 0x02, 0x6b, 0x85, 0x86, 0x8e,
0xe0, 0xd0, 0x1b, 0xfa, 0x13, 0x17, 0xab, 0x95, 0xb0, 0xc1, 0xbb, 0x3a, 0x54, 0xbd, 0xe1, 0xe4,
0xc2, 0x2e, 0xe5, 0xd2, 0xa5, 0x5d, 0x7e, 0xe1, 0xfe, 0x70, 0x3d, 0x0f, 0xe5, 0xab, 0x6c, 0xaa,
0x0e, 0xd7, 0x31, 0xa7, 0x3d, 0x33, 0x1f, 0x34, 0x73, 0x7e, 0x36, 0x67, 0xb1, 0xfe, 0x56, 0xe8,
0x6c, 0xf9, 0xd2, 0xb9, 0xca, 0xc5, 0x69, 0x4d, 0x87, 0x7d, 0xf6, 0x77, 0x00, 0x00, 0x00, 0xff,
0xff, 0x84, 0xeb, 0xeb, 0x65, 0x13, 0x09, 0x00, 0x00,
}

2782
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instance_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

237
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/snapshot.pb.go generated vendored Normal file
View File

@ -0,0 +1,237 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/snapshot.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Snapshot_Status int32
const (
Snapshot_STATUS_UNSPECIFIED Snapshot_Status = 0
// Snapshot is being created.
Snapshot_CREATING Snapshot_Status = 1
// Snapshot is ready to use.
Snapshot_READY Snapshot_Status = 2
// Snapshot encountered a problem and cannot operate.
Snapshot_ERROR Snapshot_Status = 3
// Snapshot is being deleted.
Snapshot_DELETING Snapshot_Status = 4
)
var Snapshot_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Snapshot_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Snapshot_Status) String() string {
return proto.EnumName(Snapshot_Status_name, int32(x))
}
func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_snapshot_451e295e1dfe1b62, []int{0, 0}
}
// A Snapshot resource. For more information, see [Snapshots](/docs/compute/concepts/snapshot).
type Snapshot struct {
// ID of the snapshot.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the snapshot belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the snapshot. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Size of the snapshot, specified in bytes.
StorageSize int64 `protobuf:"varint,7,opt,name=storage_size,json=storageSize,proto3" json:"storage_size,omitempty"`
// Size of the disk when the snapshot was created, specified in bytes.
DiskSize int64 `protobuf:"varint,8,opt,name=disk_size,json=diskSize,proto3" json:"disk_size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,9,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the snapshot.
Status Snapshot_Status `protobuf:"varint,10,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Snapshot_Status" json:"status,omitempty"`
// ID of the source disk used to create this snapshot.
SourceDiskId string `protobuf:"bytes,11,opt,name=source_disk_id,json=sourceDiskId,proto3" json:"source_disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (*Snapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_451e295e1dfe1b62, []int{0}
}
func (m *Snapshot) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Snapshot.Unmarshal(m, b)
}
func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
}
func (dst *Snapshot) XXX_Merge(src proto.Message) {
xxx_messageInfo_Snapshot.Merge(dst, src)
}
func (m *Snapshot) XXX_Size() int {
return xxx_messageInfo_Snapshot.Size(m)
}
func (m *Snapshot) XXX_DiscardUnknown() {
xxx_messageInfo_Snapshot.DiscardUnknown(m)
}
var xxx_messageInfo_Snapshot proto.InternalMessageInfo
func (m *Snapshot) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Snapshot) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Snapshot) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Snapshot) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Snapshot) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Snapshot) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Snapshot) GetStorageSize() int64 {
if m != nil {
return m.StorageSize
}
return 0
}
func (m *Snapshot) GetDiskSize() int64 {
if m != nil {
return m.DiskSize
}
return 0
}
func (m *Snapshot) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Snapshot) GetStatus() Snapshot_Status {
if m != nil {
return m.Status
}
return Snapshot_STATUS_UNSPECIFIED
}
func (m *Snapshot) GetSourceDiskId() string {
if m != nil {
return m.SourceDiskId
}
return ""
}
func init() {
proto.RegisterType((*Snapshot)(nil), "yandex.cloud.compute.v1.Snapshot")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Snapshot.LabelsEntry")
proto.RegisterEnum("yandex.cloud.compute.v1.Snapshot_Status", Snapshot_Status_name, Snapshot_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/snapshot.proto", fileDescriptor_snapshot_451e295e1dfe1b62)
}
var fileDescriptor_snapshot_451e295e1dfe1b62 = []byte{
// 484 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x41, 0x8f, 0x9b, 0x3e,
0x10, 0xc5, 0xff, 0x84, 0x24, 0xff, 0x30, 0x44, 0x11, 0xb2, 0xaa, 0x16, 0xa5, 0x87, 0xa5, 0xab,
0xaa, 0xe2, 0x12, 0xd0, 0xa6, 0x97, 0x6e, 0x7b, 0x69, 0x9a, 0xd0, 0x0a, 0x69, 0xb5, 0xad, 0x4c,
0xf6, 0xd0, 0x5e, 0x10, 0xc1, 0x5e, 0xd6, 0x0a, 0xc1, 0x08, 0x9b, 0xa8, 0xd9, 0x2f, 0xd8, 0xaf,
0x55, 0x61, 0x1c, 0x69, 0x2f, 0xab, 0xde, 0x86, 0x37, 0xbf, 0xf1, 0xf3, 0xc3, 0x03, 0xef, 0x4e,
0x59, 0x45, 0xe8, 0xef, 0x30, 0x2f, 0x79, 0x4b, 0xc2, 0x9c, 0x1f, 0xea, 0x56, 0xd2, 0xf0, 0x78,
0x15, 0x8a, 0x2a, 0xab, 0xc5, 0x03, 0x97, 0x41, 0xdd, 0x70, 0xc9, 0xd1, 0xab, 0x9e, 0x0b, 0x14,
0x17, 0x68, 0x2e, 0x38, 0x5e, 0xcd, 0x2f, 0x0a, 0xce, 0x8b, 0x92, 0x86, 0x0a, 0xdb, 0xb5, 0xf7,
0xa1, 0x64, 0x07, 0x2a, 0x64, 0x76, 0xa8, 0xfb, 0xc9, 0xcb, 0x3f, 0x43, 0x98, 0x24, 0xfa, 0x30,
0x34, 0x83, 0x01, 0x23, 0xae, 0xe1, 0x19, 0xbe, 0x85, 0x07, 0x8c, 0xa0, 0xd7, 0x60, 0xdd, 0xf3,
0x92, 0xd0, 0x26, 0x65, 0xc4, 0x1d, 0x28, 0x79, 0xd2, 0x0b, 0x31, 0x41, 0xd7, 0x00, 0x79, 0x43,
0x33, 0x49, 0x49, 0x9a, 0x49, 0xd7, 0xf4, 0x0c, 0xdf, 0x5e, 0xce, 0x83, 0xde, 0x2f, 0x38, 0xfb,
0x05, 0xdb, 0xb3, 0x1f, 0xb6, 0x34, 0xbd, 0x92, 0x08, 0xc1, 0xb0, 0xca, 0x0e, 0xd4, 0x1d, 0xaa,
0x23, 0x55, 0x8d, 0x3c, 0xb0, 0x09, 0x15, 0x79, 0xc3, 0x6a, 0xc9, 0x78, 0xe5, 0x8e, 0x54, 0xeb,
0xa9, 0x84, 0x22, 0x18, 0x97, 0xd9, 0x8e, 0x96, 0xc2, 0x1d, 0x7b, 0xa6, 0x6f, 0x2f, 0x17, 0xc1,
0x33, 0xa9, 0x83, 0x73, 0xa0, 0xe0, 0x46, 0xf1, 0x51, 0x25, 0x9b, 0x13, 0xd6, 0xc3, 0xe8, 0x0d,
0x4c, 0x85, 0xe4, 0x4d, 0x56, 0xd0, 0x54, 0xb0, 0x47, 0xea, 0xfe, 0xef, 0x19, 0xbe, 0x89, 0x6d,
0xad, 0x25, 0xec, 0x91, 0x76, 0xb9, 0x09, 0x13, 0xfb, 0xbe, 0x3f, 0x51, 0xfd, 0x49, 0x27, 0xa8,
0xe6, 0x05, 0xd8, 0x75, 0xc3, 0x49, 0x9b, 0xcb, 0x94, 0x11, 0xe1, 0x5a, 0x9e, 0xe9, 0x5b, 0x18,
0xb4, 0x14, 0x13, 0x81, 0x3e, 0xc3, 0x58, 0xc8, 0x4c, 0xb6, 0xc2, 0x05, 0xcf, 0xf0, 0x67, 0x4b,
0xff, 0xdf, 0xf7, 0x4c, 0x14, 0x8f, 0xf5, 0x1c, 0x7a, 0x0b, 0x33, 0xc1, 0xdb, 0x26, 0xa7, 0xa9,
0xba, 0x06, 0x23, 0xae, 0xad, 0x7e, 0xc7, 0xb4, 0x57, 0x37, 0x4c, 0xec, 0x63, 0x32, 0xbf, 0x06,
0xfb, 0x49, 0x3e, 0xe4, 0x80, 0xb9, 0xa7, 0x27, 0xfd, 0x7a, 0x5d, 0x89, 0x5e, 0xc0, 0xe8, 0x98,
0x95, 0x2d, 0xd5, 0x4f, 0xd7, 0x7f, 0x7c, 0x1c, 0x7c, 0x30, 0x2e, 0x31, 0x8c, 0x7b, 0x4b, 0xf4,
0x12, 0x50, 0xb2, 0x5d, 0x6d, 0xef, 0x92, 0xf4, 0xee, 0x36, 0xf9, 0x11, 0xad, 0xe3, 0xaf, 0x71,
0xb4, 0x71, 0xfe, 0x43, 0x53, 0x98, 0xac, 0x71, 0xb4, 0xda, 0xc6, 0xb7, 0xdf, 0x1c, 0x03, 0x59,
0x30, 0xc2, 0xd1, 0x6a, 0xf3, 0xd3, 0x19, 0x74, 0x65, 0x84, 0xf1, 0x77, 0xec, 0x98, 0x1d, 0xb3,
0x89, 0x6e, 0x22, 0xc5, 0x0c, 0xbf, 0x44, 0xbf, 0xd6, 0x05, 0x93, 0x0f, 0xed, 0xae, 0x4b, 0x18,
0xf6, 0x91, 0x17, 0xfd, 0xe2, 0x16, 0x7c, 0x51, 0xd0, 0x4a, 0xed, 0x44, 0xf8, 0xcc, 0x46, 0x7f,
0xd2, 0xe5, 0x6e, 0xac, 0xb0, 0xf7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xec, 0x41, 0x99,
0xfb, 0x02, 0x00, 0x00,
}

976
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/snapshot_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,976 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/snapshot_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import field_mask "google.golang.org/genproto/protobuf/field_mask"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetSnapshotRequest struct {
// ID of the Snapshot resource to return.
// To get the snapshot ID, use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetSnapshotRequest) Reset() { *m = GetSnapshotRequest{} }
func (m *GetSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*GetSnapshotRequest) ProtoMessage() {}
func (*GetSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{0}
}
func (m *GetSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetSnapshotRequest.Unmarshal(m, b)
}
func (m *GetSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *GetSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetSnapshotRequest.Merge(dst, src)
}
func (m *GetSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_GetSnapshotRequest.Size(m)
}
func (m *GetSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetSnapshotRequest proto.InternalMessageInfo
func (m *GetSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type ListSnapshotsRequest struct {
// ID of the folder to list snapshots in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListSnapshotsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListSnapshotsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
// The expression must specify:
// 1. The field name. Currently you can use filtering only on the [Snapshot.name] field.
// 2. An operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
// 3. The value. Мust be 3-63 characters long and match the regular expression `^[a-z]([-a-z0-9]{,61}[a-z0-9])?$`.
Filter string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotsRequest) Reset() { *m = ListSnapshotsRequest{} }
func (m *ListSnapshotsRequest) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotsRequest) ProtoMessage() {}
func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{1}
}
func (m *ListSnapshotsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotsRequest.Unmarshal(m, b)
}
func (m *ListSnapshotsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotsRequest.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotsRequest.Merge(dst, src)
}
func (m *ListSnapshotsRequest) XXX_Size() int {
return xxx_messageInfo_ListSnapshotsRequest.Size(m)
}
func (m *ListSnapshotsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotsRequest proto.InternalMessageInfo
func (m *ListSnapshotsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListSnapshotsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListSnapshotsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListSnapshotsRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
type ListSnapshotsResponse struct {
// List of snapshots.
Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListSnapshotsRequest.page_size], use
// the [next_page_token] as the value
// for the [ListSnapshotsRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotsResponse) Reset() { *m = ListSnapshotsResponse{} }
func (m *ListSnapshotsResponse) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotsResponse) ProtoMessage() {}
func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{2}
}
func (m *ListSnapshotsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotsResponse.Unmarshal(m, b)
}
func (m *ListSnapshotsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotsResponse.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotsResponse.Merge(dst, src)
}
func (m *ListSnapshotsResponse) XXX_Size() int {
return xxx_messageInfo_ListSnapshotsResponse.Size(m)
}
func (m *ListSnapshotsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotsResponse proto.InternalMessageInfo
func (m *ListSnapshotsResponse) GetSnapshots() []*Snapshot {
if m != nil {
return m.Snapshots
}
return nil
}
func (m *ListSnapshotsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateSnapshotRequest struct {
// ID of the folder to create a snapshot in.
// To get the folder ID use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// ID of the disk to create the snapshot from.
// To get the disk ID use a [yandex.cloud.compute.v1.DiskService.List] request.
DiskId string `protobuf:"bytes,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
// Name of the snapshot.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateSnapshotRequest) Reset() { *m = CreateSnapshotRequest{} }
func (m *CreateSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*CreateSnapshotRequest) ProtoMessage() {}
func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{3}
}
func (m *CreateSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateSnapshotRequest.Unmarshal(m, b)
}
func (m *CreateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *CreateSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateSnapshotRequest.Merge(dst, src)
}
func (m *CreateSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_CreateSnapshotRequest.Size(m)
}
func (m *CreateSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateSnapshotRequest proto.InternalMessageInfo
func (m *CreateSnapshotRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *CreateSnapshotRequest) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
func (m *CreateSnapshotRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateSnapshotRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *CreateSnapshotRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type CreateSnapshotMetadata struct {
// ID of the snapshot that is being created.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// ID of the source disk used to create this snapshot.
DiskId string `protobuf:"bytes,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateSnapshotMetadata) Reset() { *m = CreateSnapshotMetadata{} }
func (m *CreateSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateSnapshotMetadata) ProtoMessage() {}
func (*CreateSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{4}
}
func (m *CreateSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateSnapshotMetadata.Unmarshal(m, b)
}
func (m *CreateSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateSnapshotMetadata.Merge(dst, src)
}
func (m *CreateSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_CreateSnapshotMetadata.Size(m)
}
func (m *CreateSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateSnapshotMetadata proto.InternalMessageInfo
func (m *CreateSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *CreateSnapshotMetadata) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
type UpdateSnapshotRequest struct {
// ID of the Snapshot resource to update.
// To get the snapshot ID use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// Field mask that specifies which fields of the Snapshot resource are going to be updated.
UpdateMask *field_mask.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
// Name of the snapshot.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `key:value` pairs.
//
// Existing set of `labels` is completely replaced by the provided set.
Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateSnapshotRequest) Reset() { *m = UpdateSnapshotRequest{} }
func (m *UpdateSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSnapshotRequest) ProtoMessage() {}
func (*UpdateSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{5}
}
func (m *UpdateSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateSnapshotRequest.Unmarshal(m, b)
}
func (m *UpdateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateSnapshotRequest.Merge(dst, src)
}
func (m *UpdateSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_UpdateSnapshotRequest.Size(m)
}
func (m *UpdateSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateSnapshotRequest proto.InternalMessageInfo
func (m *UpdateSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *UpdateSnapshotRequest) GetUpdateMask() *field_mask.FieldMask {
if m != nil {
return m.UpdateMask
}
return nil
}
func (m *UpdateSnapshotRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UpdateSnapshotRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *UpdateSnapshotRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type UpdateSnapshotMetadata struct {
// ID of the Snapshot resource that is being updated.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateSnapshotMetadata) Reset() { *m = UpdateSnapshotMetadata{} }
func (m *UpdateSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateSnapshotMetadata) ProtoMessage() {}
func (*UpdateSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{6}
}
func (m *UpdateSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateSnapshotMetadata.Unmarshal(m, b)
}
func (m *UpdateSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateSnapshotMetadata.Merge(dst, src)
}
func (m *UpdateSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateSnapshotMetadata.Size(m)
}
func (m *UpdateSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateSnapshotMetadata proto.InternalMessageInfo
func (m *UpdateSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type DeleteSnapshotRequest struct {
// ID of the snapshot to delete.
// To get the snapshot ID, use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteSnapshotRequest) Reset() { *m = DeleteSnapshotRequest{} }
func (m *DeleteSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteSnapshotRequest) ProtoMessage() {}
func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{7}
}
func (m *DeleteSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteSnapshotRequest.Unmarshal(m, b)
}
func (m *DeleteSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteSnapshotRequest.Merge(dst, src)
}
func (m *DeleteSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_DeleteSnapshotRequest.Size(m)
}
func (m *DeleteSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteSnapshotRequest proto.InternalMessageInfo
func (m *DeleteSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type DeleteSnapshotMetadata struct {
// ID of the snapshot that is being deleted.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteSnapshotMetadata) Reset() { *m = DeleteSnapshotMetadata{} }
func (m *DeleteSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteSnapshotMetadata) ProtoMessage() {}
func (*DeleteSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{8}
}
func (m *DeleteSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteSnapshotMetadata.Unmarshal(m, b)
}
func (m *DeleteSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteSnapshotMetadata.Merge(dst, src)
}
func (m *DeleteSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteSnapshotMetadata.Size(m)
}
func (m *DeleteSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteSnapshotMetadata proto.InternalMessageInfo
func (m *DeleteSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type ListSnapshotOperationsRequest struct {
// ID of the Snapshot resource to list operations for.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListSnapshotOperationsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListSnapshotOperationsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotOperationsRequest) Reset() { *m = ListSnapshotOperationsRequest{} }
func (m *ListSnapshotOperationsRequest) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotOperationsRequest) ProtoMessage() {}
func (*ListSnapshotOperationsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{9}
}
func (m *ListSnapshotOperationsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotOperationsRequest.Unmarshal(m, b)
}
func (m *ListSnapshotOperationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotOperationsRequest.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotOperationsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotOperationsRequest.Merge(dst, src)
}
func (m *ListSnapshotOperationsRequest) XXX_Size() int {
return xxx_messageInfo_ListSnapshotOperationsRequest.Size(m)
}
func (m *ListSnapshotOperationsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotOperationsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotOperationsRequest proto.InternalMessageInfo
func (m *ListSnapshotOperationsRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *ListSnapshotOperationsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListSnapshotOperationsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListSnapshotOperationsResponse struct {
// List of operations for the specified snapshot.
Operations []*operation.Operation `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListSnapshotOperationsRequest.page_size], use the [next_page_token] as the value
// for the [ListSnapshotOperationsRequest.page_token] query parameter in the next list request.
// Each subsequent list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotOperationsResponse) Reset() { *m = ListSnapshotOperationsResponse{} }
func (m *ListSnapshotOperationsResponse) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotOperationsResponse) ProtoMessage() {}
func (*ListSnapshotOperationsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_fcde162cfe51d598, []int{10}
}
func (m *ListSnapshotOperationsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotOperationsResponse.Unmarshal(m, b)
}
func (m *ListSnapshotOperationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotOperationsResponse.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotOperationsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotOperationsResponse.Merge(dst, src)
}
func (m *ListSnapshotOperationsResponse) XXX_Size() int {
return xxx_messageInfo_ListSnapshotOperationsResponse.Size(m)
}
func (m *ListSnapshotOperationsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotOperationsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotOperationsResponse proto.InternalMessageInfo
func (m *ListSnapshotOperationsResponse) GetOperations() []*operation.Operation {
if m != nil {
return m.Operations
}
return nil
}
func (m *ListSnapshotOperationsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetSnapshotRequest)(nil), "yandex.cloud.compute.v1.GetSnapshotRequest")
proto.RegisterType((*ListSnapshotsRequest)(nil), "yandex.cloud.compute.v1.ListSnapshotsRequest")
proto.RegisterType((*ListSnapshotsResponse)(nil), "yandex.cloud.compute.v1.ListSnapshotsResponse")
proto.RegisterType((*CreateSnapshotRequest)(nil), "yandex.cloud.compute.v1.CreateSnapshotRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.CreateSnapshotRequest.LabelsEntry")
proto.RegisterType((*CreateSnapshotMetadata)(nil), "yandex.cloud.compute.v1.CreateSnapshotMetadata")
proto.RegisterType((*UpdateSnapshotRequest)(nil), "yandex.cloud.compute.v1.UpdateSnapshotRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.UpdateSnapshotRequest.LabelsEntry")
proto.RegisterType((*UpdateSnapshotMetadata)(nil), "yandex.cloud.compute.v1.UpdateSnapshotMetadata")
proto.RegisterType((*DeleteSnapshotRequest)(nil), "yandex.cloud.compute.v1.DeleteSnapshotRequest")
proto.RegisterType((*DeleteSnapshotMetadata)(nil), "yandex.cloud.compute.v1.DeleteSnapshotMetadata")
proto.RegisterType((*ListSnapshotOperationsRequest)(nil), "yandex.cloud.compute.v1.ListSnapshotOperationsRequest")
proto.RegisterType((*ListSnapshotOperationsResponse)(nil), "yandex.cloud.compute.v1.ListSnapshotOperationsResponse")
}
// 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
// SnapshotServiceClient is the client API for SnapshotService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SnapshotServiceClient interface {
// Returns the specified Snapshot resource.
//
// To get the list of available Snapshot resources, make a [List] request.
Get(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error)
// Retrieves the list of Snapshot resources in the specified folder.
List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
// Creates a snapshot of the specified disk.
Create(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Updates the specified snapshot.
//
// Values of omitted parameters are not changed.
Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified snapshot.
//
// Deleting a snapshot removes its data permanently and is irreversible.
Delete(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Lists operations for the specified snapshot.
ListOperations(ctx context.Context, in *ListSnapshotOperationsRequest, opts ...grpc.CallOption) (*ListSnapshotOperationsResponse, error)
}
type snapshotServiceClient struct {
cc *grpc.ClientConn
}
func NewSnapshotServiceClient(cc *grpc.ClientConn) SnapshotServiceClient {
return &snapshotServiceClient{cc}
}
func (c *snapshotServiceClient) Get(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) {
out := new(Snapshot)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error) {
out := new(ListSnapshotsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Create(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Update", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Delete(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) ListOperations(ctx context.Context, in *ListSnapshotOperationsRequest, opts ...grpc.CallOption) (*ListSnapshotOperationsResponse, error) {
out := new(ListSnapshotOperationsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/ListOperations", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SnapshotServiceServer is the server API for SnapshotService service.
type SnapshotServiceServer interface {
// Returns the specified Snapshot resource.
//
// To get the list of available Snapshot resources, make a [List] request.
Get(context.Context, *GetSnapshotRequest) (*Snapshot, error)
// Retrieves the list of Snapshot resources in the specified folder.
List(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
// Creates a snapshot of the specified disk.
Create(context.Context, *CreateSnapshotRequest) (*operation.Operation, error)
// Updates the specified snapshot.
//
// Values of omitted parameters are not changed.
Update(context.Context, *UpdateSnapshotRequest) (*operation.Operation, error)
// Deletes the specified snapshot.
//
// Deleting a snapshot removes its data permanently and is irreversible.
Delete(context.Context, *DeleteSnapshotRequest) (*operation.Operation, error)
// Lists operations for the specified snapshot.
ListOperations(context.Context, *ListSnapshotOperationsRequest) (*ListSnapshotOperationsResponse, error)
}
func RegisterSnapshotServiceServer(s *grpc.Server, srv SnapshotServiceServer) {
s.RegisterService(&_SnapshotService_serviceDesc, srv)
}
func _SnapshotService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Get(ctx, req.(*GetSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListSnapshotsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).List(ctx, req.(*ListSnapshotsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Create(ctx, req.(*CreateSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Update(ctx, req.(*UpdateSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Delete(ctx, req.(*DeleteSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_ListOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListSnapshotOperationsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).ListOperations(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/ListOperations",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).ListOperations(ctx, req.(*ListSnapshotOperationsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _SnapshotService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.SnapshotService",
HandlerType: (*SnapshotServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _SnapshotService_Get_Handler,
},
{
MethodName: "List",
Handler: _SnapshotService_List_Handler,
},
{
MethodName: "Create",
Handler: _SnapshotService_Create_Handler,
},
{
MethodName: "Update",
Handler: _SnapshotService_Update_Handler,
},
{
MethodName: "Delete",
Handler: _SnapshotService_Delete_Handler,
},
{
MethodName: "ListOperations",
Handler: _SnapshotService_ListOperations_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/snapshot_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/snapshot_service.proto", fileDescriptor_snapshot_service_fcde162cfe51d598)
}
var fileDescriptor_snapshot_service_fcde162cfe51d598 = []byte{
// 984 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x41, 0x6f, 0xdc, 0x44,
0x14, 0xd6, 0x64, 0x13, 0x37, 0xfb, 0x16, 0x68, 0x35, 0xea, 0x36, 0x2b, 0x8b, 0x40, 0x6a, 0xd4,
0xb2, 0x6c, 0xb0, 0xbd, 0xde, 0x92, 0x85, 0xa4, 0xad, 0x2a, 0x12, 0x92, 0x2a, 0x52, 0x2b, 0x90,
0x53, 0x2e, 0x44, 0x65, 0x35, 0x89, 0x27, 0x5b, 0x6b, 0x1d, 0xdb, 0xec, 0x78, 0x57, 0x4d, 0x4a,
0x25, 0x14, 0x71, 0x0a, 0xc7, 0xde, 0x91, 0x10, 0xbf, 0x80, 0x9c, 0x8a, 0xf8, 0x01, 0xc9, 0xb9,
0xfc, 0x05, 0x0e, 0x5c, 0xe9, 0x91, 0x13, 0xf2, 0xcc, 0x78, 0xb3, 0x9b, 0xd8, 0x8d, 0x03, 0x08,
0x71, 0x1b, 0xfb, 0x7d, 0xef, 0xcd, 0x37, 0xef, 0xbd, 0xf9, 0xde, 0x80, 0xb1, 0x43, 0x7c, 0x87,
0x3e, 0x36, 0x37, 0xbd, 0xa0, 0xe7, 0x98, 0x9b, 0xc1, 0x76, 0xd8, 0x8b, 0xa8, 0xd9, 0xb7, 0x4c,
0xe6, 0x93, 0x90, 0x3d, 0x0a, 0xa2, 0x16, 0xa3, 0xdd, 0xbe, 0xbb, 0x49, 0x8d, 0xb0, 0x1b, 0x44,
0x01, 0x9e, 0x12, 0x78, 0x83, 0xe3, 0x0d, 0x89, 0x37, 0xfa, 0x96, 0xfa, 0x66, 0x3b, 0x08, 0xda,
0x1e, 0x35, 0x49, 0xe8, 0x9a, 0xc4, 0xf7, 0x83, 0x88, 0x44, 0x6e, 0xe0, 0x33, 0xe1, 0xa6, 0xce,
0x48, 0x2b, 0xff, 0xda, 0xe8, 0x6d, 0x99, 0x5b, 0x2e, 0xf5, 0x9c, 0xd6, 0x36, 0x61, 0x1d, 0x89,
0x50, 0x25, 0x91, 0xd8, 0x3f, 0x08, 0x69, 0x97, 0xbb, 0x4b, 0xdb, 0xf5, 0xb3, 0x48, 0xa6, 0xe2,
0x06, 0x51, 0x4e, 0xc5, 0x9b, 0x1e, 0xc1, 0xf5, 0x89, 0xe7, 0x3a, 0x43, 0x66, 0x6d, 0x09, 0xf0,
0x5d, 0x1a, 0xad, 0xc9, 0xd8, 0x36, 0xfd, 0xaa, 0x47, 0x59, 0x84, 0x75, 0x28, 0x0d, 0x72, 0xe2,
0x3a, 0x15, 0x34, 0x83, 0xaa, 0xc5, 0xc5, 0xd7, 0x7e, 0x3f, 0xb4, 0xd0, 0xfe, 0x91, 0x35, 0x7e,
0xeb, 0xf6, 0x5c, 0xdd, 0x86, 0x04, 0xb0, 0xea, 0x68, 0xcf, 0x11, 0x5c, 0xbe, 0xe7, 0xb2, 0x41,
0x18, 0x96, 0xc4, 0x79, 0x0f, 0x8a, 0x5b, 0x81, 0xe7, 0xd0, 0x6e, 0x56, 0x94, 0x49, 0x61, 0x5e,
0x75, 0xf0, 0xbb, 0x50, 0x0c, 0x49, 0x9b, 0xb6, 0x98, 0xbb, 0x4b, 0x2b, 0x63, 0x33, 0xa8, 0x5a,
0x58, 0x84, 0x3f, 0x0f, 0x2d, 0xe5, 0xd6, 0x6d, 0xab, 0x5e, 0xaf, 0xdb, 0x93, 0xb1, 0x71, 0xcd,
0xdd, 0xa5, 0xb8, 0x0a, 0xc0, 0x81, 0x51, 0xd0, 0xa1, 0x7e, 0xa5, 0xc0, 0x83, 0x16, 0xf7, 0x8f,
0xac, 0x09, 0x8e, 0xb4, 0x79, 0x94, 0x07, 0xb1, 0x0d, 0x6b, 0xa0, 0x6c, 0xb9, 0x5e, 0x44, 0xbb,
0x95, 0x71, 0x8e, 0x82, 0xfd, 0xa3, 0x41, 0x3c, 0x69, 0xd1, 0xbe, 0x41, 0x50, 0x3e, 0x41, 0x9d,
0x85, 0x81, 0xcf, 0x28, 0xbe, 0x03, 0xc5, 0xe4, 0x88, 0xac, 0x82, 0x66, 0x0a, 0xd5, 0x52, 0xe3,
0xaa, 0x91, 0xd1, 0x11, 0xc6, 0x20, 0x81, 0xc7, 0x3e, 0xf8, 0x3a, 0x5c, 0xf4, 0xe9, 0xe3, 0xa8,
0x35, 0xc4, 0x36, 0x3e, 0x57, 0xd1, 0x7e, 0x3d, 0xfe, 0xfd, 0x59, 0x42, 0x53, 0xfb, 0xbe, 0x00,
0xe5, 0xa5, 0x2e, 0x25, 0x11, 0x3d, 0x59, 0x86, 0x73, 0xa4, 0xef, 0x1a, 0x5c, 0x70, 0x5c, 0xd6,
0x89, 0x81, 0x63, 0x29, 0x40, 0x25, 0x36, 0xae, 0x3a, 0x78, 0x0e, 0xc6, 0x7d, 0xb2, 0x4d, 0x65,
0xda, 0xae, 0xbe, 0x3c, 0xb4, 0xa6, 0xbf, 0x5e, 0x27, 0xfa, 0xee, 0xc3, 0x75, 0x9d, 0xe8, 0xbb,
0x75, 0x7d, 0xfe, 0xe1, 0x13, 0xeb, 0xfd, 0xa6, 0xf5, 0x74, 0x5d, 0x7e, 0xd9, 0x1c, 0x8e, 0x67,
0xa1, 0xe4, 0x50, 0xb6, 0xd9, 0x75, 0xc3, 0xb8, 0x75, 0x64, 0x3a, 0x65, 0xd2, 0x1b, 0x73, 0x4d,
0x7b, 0xd8, 0x8a, 0x9f, 0x21, 0x50, 0x3c, 0xb2, 0x41, 0x3d, 0x56, 0x51, 0x78, 0xda, 0x16, 0x32,
0xd3, 0x96, 0x7a, 0x6c, 0xe3, 0x1e, 0x77, 0x5e, 0xf6, 0xa3, 0xee, 0xce, 0xe2, 0x9d, 0x97, 0x87,
0x56, 0x69, 0x5d, 0x6f, 0xd5, 0xf5, 0xf9, 0x98, 0x66, 0x6d, 0x8f, 0x9f, 0xa8, 0xf9, 0x81, 0x38,
0x59, 0xf3, 0xc6, 0xc1, 0x91, 0xa5, 0xa8, 0xe3, 0x96, 0xce, 0x57, 0x18, 0x5f, 0x92, 0x87, 0x19,
0xe0, 0x6d, 0x49, 0x45, 0x9d, 0x87, 0xd2, 0x50, 0x5c, 0x7c, 0x09, 0x0a, 0x1d, 0xba, 0x23, 0x92,
0x6a, 0xc7, 0x4b, 0x7c, 0x19, 0x26, 0xfa, 0xc4, 0xeb, 0x51, 0x59, 0x24, 0xf1, 0xb1, 0x30, 0xf6,
0x11, 0xd2, 0x6c, 0xb8, 0x32, 0x4a, 0xf4, 0x3e, 0x8d, 0x88, 0x43, 0x22, 0x82, 0xdf, 0x4e, 0xb9,
0x27, 0xc3, 0x37, 0x03, 0x4f, 0x9d, 0x28, 0x4b, 0x52, 0x08, 0xed, 0x79, 0x01, 0xca, 0x9f, 0x87,
0x4e, 0x4a, 0xd1, 0xcf, 0x77, 0xf7, 0xf0, 0x4d, 0x28, 0xf5, 0x78, 0x1c, 0x2e, 0x30, 0x7c, 0x97,
0x52, 0x43, 0x35, 0x84, 0x06, 0x19, 0x89, 0x06, 0x19, 0x2b, 0xb1, 0x06, 0xdd, 0x27, 0xac, 0x63,
0x83, 0x80, 0xc7, 0xeb, 0xff, 0xba, 0x1d, 0x26, 0xce, 0x68, 0x87, 0xd4, 0x84, 0xfc, 0xef, 0xda,
0x61, 0x1e, 0xae, 0x8c, 0x12, 0xcd, 0xdd, 0x0e, 0xda, 0x0a, 0x94, 0x3f, 0xa1, 0x1e, 0xfd, 0xa7,
0x45, 0x8f, 0x29, 0x8c, 0xc6, 0xc9, 0x4f, 0xe1, 0x07, 0x04, 0xd3, 0xc3, 0x82, 0xf7, 0x69, 0x32,
0x2f, 0xd8, 0xdf, 0x6c, 0xc0, 0x7f, 0x5f, 0xb8, 0xb5, 0xef, 0x10, 0xbc, 0x95, 0xc5, 0x51, 0xaa,
0xf3, 0xc7, 0x00, 0x83, 0x49, 0x97, 0x21, 0xcf, 0xc7, 0x93, 0x70, 0xe0, 0x6f, 0x0f, 0x39, 0xe5,
0xd5, 0xe7, 0xc6, 0x1f, 0x17, 0xe0, 0x62, 0xc2, 0x64, 0x4d, 0x3c, 0x10, 0xf0, 0x1e, 0x82, 0xc2,
0x5d, 0x1a, 0xe1, 0xd9, 0xcc, 0x5e, 0x3e, 0x3d, 0x55, 0xd5, 0xb3, 0xc7, 0x87, 0x36, 0xbb, 0xf7,
0xeb, 0x6f, 0xcf, 0xc6, 0xae, 0xe1, 0x77, 0xd2, 0x26, 0x3f, 0x33, 0x9f, 0x0c, 0x15, 0xe6, 0x29,
0xfe, 0x16, 0xc1, 0x78, 0x9c, 0x26, 0xac, 0x67, 0x06, 0x4e, 0x9b, 0xca, 0xaa, 0x91, 0x17, 0x2e,
0x72, 0xad, 0x4d, 0x73, 0x52, 0x53, 0xb8, 0x9c, 0x4a, 0x0a, 0xff, 0x88, 0x40, 0x11, 0xfa, 0x88,
0x8d, 0xf3, 0x29, 0xbd, 0x7a, 0x76, 0xc5, 0xb4, 0x95, 0x83, 0x17, 0x35, 0x2d, 0x53, 0x80, 0x27,
0x93, 0x3f, 0x9c, 0xa2, 0xaa, 0xa5, 0x53, 0x5c, 0x40, 0x35, 0xfc, 0x13, 0x02, 0x45, 0x5c, 0xdb,
0x57, 0xb0, 0x4c, 0x15, 0xa0, 0x3c, 0x2c, 0x1f, 0x08, 0x96, 0x19, 0xba, 0x30, 0xca, 0xb2, 0xda,
0xc8, 0x53, 0xdd, 0x98, 0xf3, 0x2f, 0x08, 0x14, 0x71, 0xcf, 0x5f, 0xc1, 0x39, 0x55, 0x50, 0xf2,
0x70, 0xfe, 0xf2, 0xe0, 0x45, 0xcd, 0xcc, 0x14, 0x92, 0xf2, 0xc9, 0x09, 0xb2, 0xbc, 0x1d, 0x46,
0x3b, 0xa2, 0x3d, 0x6b, 0xb9, 0xda, 0xf3, 0x67, 0x04, 0x6f, 0xc4, 0x0d, 0x75, 0x7c, 0x7b, 0x71,
0x33, 0x57, 0xe7, 0x9d, 0x92, 0x24, 0xf5, 0xc3, 0x73, 0xfb, 0xc9, 0xd6, 0x6d, 0x72, 0xc2, 0x75,
0x6c, 0xe4, 0x20, 0x7c, 0xfc, 0x74, 0x66, 0x8b, 0xcb, 0x5f, 0x2c, 0xb5, 0xdd, 0xe8, 0x51, 0x6f,
0x23, 0xde, 0xcb, 0x14, 0x9b, 0xeb, 0xe2, 0x09, 0xdd, 0x0e, 0xf4, 0x36, 0xf5, 0x79, 0x5a, 0xcc,
0x8c, 0xb7, 0xfa, 0x4d, 0xb9, 0xdc, 0x50, 0x38, 0xec, 0xc6, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff,
0xfd, 0xcf, 0xec, 0x9e, 0x7a, 0x0c, 0x00, 0x00,
}

133
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/zone.pb.go generated vendored Normal file
View File

@ -0,0 +1,133 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/zone.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Zone_Status int32
const (
Zone_STATUS_UNSPECIFIED Zone_Status = 0
// Zone is available. You can access the resources allocated in this zone.
Zone_UP Zone_Status = 1
// Zone is not available.
Zone_DOWN Zone_Status = 2
)
var Zone_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "UP",
2: "DOWN",
}
var Zone_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"UP": 1,
"DOWN": 2,
}
func (x Zone_Status) String() string {
return proto.EnumName(Zone_Status_name, int32(x))
}
func (Zone_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_zone_f47efd8ae474576f, []int{0, 0}
}
// Availability zone. For more information, see [Availability zones](/docs/overview/concepts/geo-scope).
type Zone struct {
// ID of the zone.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the region.
RegionId string `protobuf:"bytes,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
// Status of the zone.
Status Zone_Status `protobuf:"varint,3,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Zone_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Zone) Reset() { *m = Zone{} }
func (m *Zone) String() string { return proto.CompactTextString(m) }
func (*Zone) ProtoMessage() {}
func (*Zone) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_f47efd8ae474576f, []int{0}
}
func (m *Zone) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Zone.Unmarshal(m, b)
}
func (m *Zone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Zone.Marshal(b, m, deterministic)
}
func (dst *Zone) XXX_Merge(src proto.Message) {
xxx_messageInfo_Zone.Merge(dst, src)
}
func (m *Zone) XXX_Size() int {
return xxx_messageInfo_Zone.Size(m)
}
func (m *Zone) XXX_DiscardUnknown() {
xxx_messageInfo_Zone.DiscardUnknown(m)
}
var xxx_messageInfo_Zone proto.InternalMessageInfo
func (m *Zone) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Zone) GetRegionId() string {
if m != nil {
return m.RegionId
}
return ""
}
func (m *Zone) GetStatus() Zone_Status {
if m != nil {
return m.Status
}
return Zone_STATUS_UNSPECIFIED
}
func init() {
proto.RegisterType((*Zone)(nil), "yandex.cloud.compute.v1.Zone")
proto.RegisterEnum("yandex.cloud.compute.v1.Zone_Status", Zone_Status_name, Zone_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/zone.proto", fileDescriptor_zone_f47efd8ae474576f)
}
var fileDescriptor_zone_f47efd8ae474576f = []byte{
// 237 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xaa, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2d, 0x28, 0x2d, 0x49,
0xd5, 0x2f, 0x33, 0xd4, 0xaf, 0xca, 0xcf, 0x4b, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12,
0x87, 0xa8, 0xd1, 0x03, 0xab, 0xd1, 0x83, 0xaa, 0xd1, 0x2b, 0x33, 0x54, 0x5a, 0xca, 0xc8, 0xc5,
0x12, 0x95, 0x9f, 0x97, 0x2a, 0xc4, 0xc7, 0xc5, 0x94, 0x99, 0x22, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1,
0x19, 0xc4, 0x94, 0x99, 0x22, 0x24, 0xcd, 0xc5, 0x59, 0x94, 0x9a, 0x9e, 0x99, 0x9f, 0x17, 0x9f,
0x99, 0x22, 0xc1, 0x04, 0x16, 0xe6, 0x80, 0x08, 0x78, 0xa6, 0x08, 0xd9, 0x70, 0xb1, 0x15, 0x97,
0x24, 0x96, 0x94, 0x16, 0x4b, 0x30, 0x2b, 0x30, 0x6a, 0xf0, 0x19, 0xa9, 0xe8, 0xe1, 0x30, 0x5f,
0x0f, 0x64, 0xb6, 0x5e, 0x30, 0x58, 0x6d, 0x10, 0x54, 0x8f, 0x92, 0x11, 0x17, 0x1b, 0x44, 0x44,
0x48, 0x8c, 0x4b, 0x28, 0x38, 0xc4, 0x31, 0x24, 0x34, 0x38, 0x3e, 0xd4, 0x2f, 0x38, 0xc0, 0xd5,
0xd9, 0xd3, 0xcd, 0xd3, 0xd5, 0x45, 0x80, 0x41, 0x88, 0x8d, 0x8b, 0x29, 0x34, 0x40, 0x80, 0x51,
0x88, 0x83, 0x8b, 0xc5, 0xc5, 0x3f, 0xdc, 0x4f, 0x80, 0xc9, 0xc9, 0x35, 0xca, 0x39, 0x3d, 0xb3,
0x24, 0xa3, 0x34, 0x09, 0x64, 0xb8, 0x3e, 0xc4, 0x36, 0x5d, 0x88, 0x8f, 0xd3, 0xf3, 0x75, 0xd3,
0x53, 0xf3, 0xc0, 0xfe, 0xd4, 0xc7, 0x11, 0x14, 0xd6, 0x50, 0x66, 0x12, 0x1b, 0x58, 0x99, 0x31,
0x20, 0x00, 0x00, 0xff, 0xff, 0xa6, 0xd7, 0x67, 0x16, 0x34, 0x01, 0x00, 0x00,
}

324
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/zone_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/zone_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type ListZonesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListZonesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListZonesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListZonesRequest) Reset() { *m = ListZonesRequest{} }
func (m *ListZonesRequest) String() string { return proto.CompactTextString(m) }
func (*ListZonesRequest) ProtoMessage() {}
func (*ListZonesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{0}
}
func (m *ListZonesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListZonesRequest.Unmarshal(m, b)
}
func (m *ListZonesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListZonesRequest.Marshal(b, m, deterministic)
}
func (dst *ListZonesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListZonesRequest.Merge(dst, src)
}
func (m *ListZonesRequest) XXX_Size() int {
return xxx_messageInfo_ListZonesRequest.Size(m)
}
func (m *ListZonesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListZonesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListZonesRequest proto.InternalMessageInfo
func (m *ListZonesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListZonesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListZonesResponse struct {
// List of availability zones.
Zones []*Zone `protobuf:"bytes,1,rep,name=zones,proto3" json:"zones,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListZonesRequest.page_size], use
// the [ListZonesRequest.page_token] as the value
// for the [ListZonesRequest.page_token] query parameter
// in the next list request. Subsequent list requests will have their own
// [ListZonesRequest.page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListZonesResponse) Reset() { *m = ListZonesResponse{} }
func (m *ListZonesResponse) String() string { return proto.CompactTextString(m) }
func (*ListZonesResponse) ProtoMessage() {}
func (*ListZonesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{1}
}
func (m *ListZonesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListZonesResponse.Unmarshal(m, b)
}
func (m *ListZonesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListZonesResponse.Marshal(b, m, deterministic)
}
func (dst *ListZonesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListZonesResponse.Merge(dst, src)
}
func (m *ListZonesResponse) XXX_Size() int {
return xxx_messageInfo_ListZonesResponse.Size(m)
}
func (m *ListZonesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListZonesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListZonesResponse proto.InternalMessageInfo
func (m *ListZonesResponse) GetZones() []*Zone {
if m != nil {
return m.Zones
}
return nil
}
func (m *ListZonesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type GetZoneRequest struct {
// ID of the availability zone to return information about.
ZoneId string `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetZoneRequest) Reset() { *m = GetZoneRequest{} }
func (m *GetZoneRequest) String() string { return proto.CompactTextString(m) }
func (*GetZoneRequest) ProtoMessage() {}
func (*GetZoneRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{2}
}
func (m *GetZoneRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetZoneRequest.Unmarshal(m, b)
}
func (m *GetZoneRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetZoneRequest.Marshal(b, m, deterministic)
}
func (dst *GetZoneRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetZoneRequest.Merge(dst, src)
}
func (m *GetZoneRequest) XXX_Size() int {
return xxx_messageInfo_GetZoneRequest.Size(m)
}
func (m *GetZoneRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetZoneRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetZoneRequest proto.InternalMessageInfo
func (m *GetZoneRequest) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func init() {
proto.RegisterType((*ListZonesRequest)(nil), "yandex.cloud.compute.v1.ListZonesRequest")
proto.RegisterType((*ListZonesResponse)(nil), "yandex.cloud.compute.v1.ListZonesResponse")
proto.RegisterType((*GetZoneRequest)(nil), "yandex.cloud.compute.v1.GetZoneRequest")
}
// 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
// ZoneServiceClient is the client API for ZoneService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ZoneServiceClient interface {
// Returns the information about the specified availability zone.
//
// To get the list of availability zones, make a [List] request.
Get(ctx context.Context, in *GetZoneRequest, opts ...grpc.CallOption) (*Zone, error)
// Retrieves the list of availability zones.
List(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error)
}
type zoneServiceClient struct {
cc *grpc.ClientConn
}
func NewZoneServiceClient(cc *grpc.ClientConn) ZoneServiceClient {
return &zoneServiceClient{cc}
}
func (c *zoneServiceClient) Get(ctx context.Context, in *GetZoneRequest, opts ...grpc.CallOption) (*Zone, error) {
out := new(Zone)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.ZoneService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *zoneServiceClient) List(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error) {
out := new(ListZonesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.ZoneService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ZoneServiceServer is the server API for ZoneService service.
type ZoneServiceServer interface {
// Returns the information about the specified availability zone.
//
// To get the list of availability zones, make a [List] request.
Get(context.Context, *GetZoneRequest) (*Zone, error)
// Retrieves the list of availability zones.
List(context.Context, *ListZonesRequest) (*ListZonesResponse, error)
}
func RegisterZoneServiceServer(s *grpc.Server, srv ZoneServiceServer) {
s.RegisterService(&_ZoneService_serviceDesc, srv)
}
func _ZoneService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetZoneRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ZoneServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.ZoneService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ZoneServiceServer).Get(ctx, req.(*GetZoneRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ZoneService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListZonesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ZoneServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.ZoneService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ZoneServiceServer).List(ctx, req.(*ListZonesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ZoneService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.ZoneService",
HandlerType: (*ZoneServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ZoneService_Get_Handler,
},
{
MethodName: "List",
Handler: _ZoneService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/zone_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/zone_service.proto", fileDescriptor_zone_service_e9c86d533e92d608)
}
var fileDescriptor_zone_service_e9c86d533e92d608 = []byte{
// 421 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x8b, 0xd3, 0x40,
0x18, 0xc6, 0xc9, 0x76, 0xb7, 0x9a, 0x59, 0xff, 0xed, 0x78, 0xb0, 0x46, 0x0b, 0x25, 0xa2, 0x1b,
0x17, 0x36, 0x93, 0x6c, 0x11, 0x0f, 0xb6, 0x97, 0x88, 0x14, 0xc1, 0x83, 0xa4, 0x9e, 0x7a, 0x29,
0x69, 0xf3, 0x12, 0x07, 0xeb, 0x4c, 0xec, 0x4c, 0x42, 0xad, 0x78, 0xf1, 0xd8, 0xab, 0x1f, 0xaa,
0xbd, 0xfb, 0x15, 0x3c, 0xf8, 0x19, 0xf4, 0x22, 0x33, 0x13, 0xc5, 0x56, 0x52, 0xf6, 0x16, 0xf2,
0xfe, 0xe6, 0x79, 0x9e, 0xf7, 0x0f, 0x3a, 0xfb, 0x98, 0xb0, 0x14, 0x16, 0x64, 0x3a, 0xe3, 0x45,
0x4a, 0xa6, 0xfc, 0x7d, 0x5e, 0x48, 0x20, 0x65, 0x48, 0x96, 0x9c, 0xc1, 0x58, 0xc0, 0xbc, 0xa4,
0x53, 0xf0, 0xf3, 0x39, 0x97, 0x1c, 0xdf, 0x31, 0xac, 0xaf, 0x59, 0xbf, 0x62, 0xfd, 0x32, 0x74,
0xee, 0x67, 0x9c, 0x67, 0x33, 0x20, 0x49, 0x4e, 0x49, 0xc2, 0x18, 0x97, 0x89, 0xa4, 0x9c, 0x09,
0xf3, 0xcc, 0x71, 0xf7, 0x59, 0x54, 0x4c, 0x7b, 0x8b, 0x29, 0x93, 0x19, 0x4d, 0xb5, 0x86, 0x29,
0xbb, 0x80, 0x6e, 0xbd, 0xa2, 0x42, 0x8e, 0x38, 0x03, 0x11, 0xc3, 0x87, 0x02, 0x84, 0xc4, 0xa7,
0xc8, 0xce, 0x93, 0x0c, 0xc6, 0x82, 0x2e, 0xa1, 0x65, 0x75, 0x2c, 0xaf, 0x11, 0xa1, 0x9f, 0xeb,
0xb0, 0xd9, 0xeb, 0x87, 0x41, 0x10, 0xc4, 0x57, 0x55, 0x71, 0x48, 0x97, 0x80, 0x3d, 0x84, 0x34,
0x28, 0xf9, 0x3b, 0x60, 0xad, 0x83, 0x8e, 0xe5, 0xd9, 0x91, 0xbd, 0xda, 0x84, 0x47, 0x9a, 0x8c,
0xb5, 0xca, 0x1b, 0x55, 0x73, 0x73, 0x74, 0xf2, 0x8f, 0x8d, 0xc8, 0x39, 0x13, 0x80, 0xbb, 0xe8,
0x48, 0x05, 0x15, 0x2d, 0xab, 0xd3, 0xf0, 0x8e, 0x2f, 0xda, 0x7e, 0xcd, 0x14, 0x7c, 0xf5, 0x2c,
0x36, 0x2c, 0x7e, 0x84, 0x6e, 0x32, 0x58, 0xc8, 0xf1, 0xae, 0x71, 0x7c, 0x5d, 0xfd, 0x7e, 0xfd,
0xd7, 0xf1, 0x29, 0xba, 0x31, 0x00, 0x6d, 0xf8, 0xa7, 0xad, 0x87, 0xe8, 0x8a, 0x1e, 0x3d, 0x4d,
0x75, 0x53, 0x76, 0x74, 0xed, 0xc7, 0x3a, 0xb4, 0x56, 0x9b, 0xf0, 0xb0, 0xd7, 0x7f, 0x12, 0xc4,
0x4d, 0x55, 0x7c, 0x99, 0x5e, 0xfc, 0xb2, 0xd0, 0xb1, 0x7a, 0x36, 0x34, 0x1b, 0xc2, 0x73, 0xd4,
0x18, 0x80, 0xc4, 0xa7, 0xb5, 0xe9, 0xb6, 0x6d, 0x9c, 0xfd, 0x6d, 0xb8, 0x0f, 0xbe, 0x7c, 0xfb,
0xfe, 0xf5, 0xa0, 0x8d, 0xef, 0xed, 0xee, 0x4b, 0x90, 0x4f, 0x55, 0xbc, 0xcf, 0x78, 0x81, 0x0e,
0xd5, 0xb8, 0xf0, 0xe3, 0x5a, 0xad, 0xdd, 0xa5, 0x39, 0x67, 0x97, 0x41, 0xcd, 0xe0, 0xdd, 0xbb,
0x3a, 0xc3, 0x6d, 0x7c, 0xf2, 0x5f, 0x86, 0xe8, 0xc5, 0xe8, 0x79, 0x46, 0xe5, 0xdb, 0x62, 0xa2,
0x14, 0x88, 0x91, 0x3c, 0x37, 0xb7, 0x93, 0xf1, 0xf3, 0x0c, 0x98, 0x3e, 0x1b, 0x52, 0x73, 0x78,
0xcf, 0xaa, 0xcf, 0x49, 0x53, 0x63, 0xdd, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x18, 0x19, 0x69,
0xb4, 0x05, 0x03, 0x00, 0x00,
}

101
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/blob.pb.go generated vendored Normal file
View File

@ -0,0 +1,101 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/blob.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A Blob resource.
type Blob struct {
// Output only. ID of the blob.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Content-addressable identifier of the blob.
Digest string `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
// Size of the blob, specified in bytes.
Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Blob) Reset() { *m = Blob{} }
func (m *Blob) String() string { return proto.CompactTextString(m) }
func (*Blob) ProtoMessage() {}
func (*Blob) Descriptor() ([]byte, []int) {
return fileDescriptor_blob_6676eeac21262de6, []int{0}
}
func (m *Blob) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Blob.Unmarshal(m, b)
}
func (m *Blob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Blob.Marshal(b, m, deterministic)
}
func (dst *Blob) XXX_Merge(src proto.Message) {
xxx_messageInfo_Blob.Merge(dst, src)
}
func (m *Blob) XXX_Size() int {
return xxx_messageInfo_Blob.Size(m)
}
func (m *Blob) XXX_DiscardUnknown() {
xxx_messageInfo_Blob.DiscardUnknown(m)
}
var xxx_messageInfo_Blob proto.InternalMessageInfo
func (m *Blob) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Blob) GetDigest() string {
if m != nil {
return m.Digest
}
return ""
}
func (m *Blob) GetSize() int64 {
if m != nil {
return m.Size
}
return 0
}
func init() {
proto.RegisterType((*Blob)(nil), "yandex.cloud.containerregistry.v1.Blob")
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/blob.proto", fileDescriptor_blob_6676eeac21262de6)
}
var fileDescriptor_blob_6676eeac21262de6 = []byte{
// 180 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xa9, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc,
0x4b, 0x2d, 0x2a, 0x4a, 0x4d, 0xcf, 0x2c, 0x2e, 0x29, 0xaa, 0xd4, 0x2f, 0x33, 0xd4, 0x4f, 0xca,
0xc9, 0x4f, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x84, 0xa8, 0xd6, 0x03, 0xab, 0xd6,
0xc3, 0x50, 0xad, 0x57, 0x66, 0xa8, 0xe4, 0xc4, 0xc5, 0xe2, 0x94, 0x93, 0x9f, 0x24, 0xc4, 0xc7,
0xc5, 0x94, 0x99, 0x22, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x19, 0xc4, 0x94, 0x99, 0x22, 0x24, 0xc6,
0xc5, 0x96, 0x92, 0x99, 0x9e, 0x5a, 0x5c, 0x22, 0xc1, 0x04, 0x16, 0x83, 0xf2, 0x84, 0x84, 0xb8,
0x58, 0x8a, 0x33, 0xab, 0x52, 0x25, 0x98, 0x15, 0x18, 0x35, 0x98, 0x83, 0xc0, 0x6c, 0xa7, 0xc8,
0xa8, 0xf0, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x88, 0x9d, 0xba,
0x10, 0x17, 0xa6, 0xe7, 0xeb, 0xa6, 0xa7, 0xe6, 0x81, 0x5d, 0xa3, 0x4f, 0xd0, 0xe9, 0xd6, 0x18,
0x82, 0x49, 0x6c, 0x60, 0xad, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xc1, 0x8c, 0x03,
0xf8, 0x00, 0x00, 0x00,
}

159
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/image.pb.go generated vendored Normal file
View File

@ -0,0 +1,159 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/image.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// An Image resource. For more information, see [Docker image](/docs/cloud/container-registry/docker-image).
type Image struct {
// Output only. ID of the Docker image.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Name of the Docker image.
// The name is unique within the registry.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// Content-addressable identifier of the Docker image.
Digest string `protobuf:"bytes,3,opt,name=digest,proto3" json:"digest,omitempty"`
// Compressed size of the Docker image, specified in bytes.
CompressedSize int64 `protobuf:"varint,4,opt,name=compressed_size,json=compressedSize,proto3" json:"compressed_size,omitempty"`
// Configuration of the Docker image.
Config *Blob `protobuf:"bytes,5,opt,name=config,proto3" json:"config,omitempty"`
// Layers of the Docker image.
Layers []*Blob `protobuf:"bytes,6,rep,name=layers,proto3" json:"layers,omitempty"`
// Tags of the Docker image.
//
// Each tag is unique within the repository.
Tags []string `protobuf:"bytes,7,rep,name=tags,proto3" json:"tags,omitempty"`
// Output only. Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,8,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Image) Reset() { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage() {}
func (*Image) Descriptor() ([]byte, []int) {
return fileDescriptor_image_cab1ec775e9195d2, []int{0}
}
func (m *Image) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Image.Unmarshal(m, b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Image.Marshal(b, m, deterministic)
}
func (dst *Image) XXX_Merge(src proto.Message) {
xxx_messageInfo_Image.Merge(dst, src)
}
func (m *Image) XXX_Size() int {
return xxx_messageInfo_Image.Size(m)
}
func (m *Image) XXX_DiscardUnknown() {
xxx_messageInfo_Image.DiscardUnknown(m)
}
var xxx_messageInfo_Image proto.InternalMessageInfo
func (m *Image) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Image) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Image) GetDigest() string {
if m != nil {
return m.Digest
}
return ""
}
func (m *Image) GetCompressedSize() int64 {
if m != nil {
return m.CompressedSize
}
return 0
}
func (m *Image) GetConfig() *Blob {
if m != nil {
return m.Config
}
return nil
}
func (m *Image) GetLayers() []*Blob {
if m != nil {
return m.Layers
}
return nil
}
func (m *Image) GetTags() []string {
if m != nil {
return m.Tags
}
return nil
}
func (m *Image) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func init() {
proto.RegisterType((*Image)(nil), "yandex.cloud.containerregistry.v1.Image")
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/image.proto", fileDescriptor_image_cab1ec775e9195d2)
}
var fileDescriptor_image_cab1ec775e9195d2 = []byte{
// 321 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x51, 0x41, 0x4b, 0x33, 0x31,
0x14, 0x64, 0x77, 0xdb, 0xfd, 0xbe, 0x46, 0xa8, 0x90, 0x83, 0x84, 0x5e, 0x5c, 0xbd, 0xb4, 0x07,
0x9b, 0x50, 0x3d, 0x89, 0x07, 0xb1, 0x37, 0xaf, 0xab, 0x20, 0x7a, 0x29, 0xd9, 0xcd, 0x6b, 0x0c,
0xec, 0x26, 0x25, 0x49, 0x8b, 0xed, 0x7f, 0xf3, 0xbf, 0xc9, 0x26, 0x2d, 0x1e, 0x7a, 0x28, 0xde,
0xde, 0x1b, 0x66, 0x86, 0x37, 0xf3, 0xd0, 0x74, 0xcb, 0xb5, 0x80, 0x2f, 0x56, 0x37, 0x66, 0x2d,
0x58, 0x6d, 0xb4, 0xe7, 0x4a, 0x83, 0xb5, 0x20, 0x95, 0xf3, 0x76, 0xcb, 0x36, 0x33, 0xa6, 0x5a,
0x2e, 0x81, 0xae, 0xac, 0xf1, 0x06, 0x5f, 0x45, 0x3a, 0x0d, 0x74, 0x7a, 0x44, 0xa7, 0x9b, 0xd9,
0xe8, 0xe6, 0xb4, 0x63, 0xd5, 0x98, 0x2a, 0x1a, 0x8e, 0x2e, 0xa5, 0x31, 0xb2, 0x01, 0x16, 0xb6,
0x6a, 0xbd, 0x64, 0x5e, 0xb5, 0xe0, 0x3c, 0x6f, 0x57, 0x91, 0x70, 0xfd, 0x9d, 0xa2, 0xfe, 0x73,
0x77, 0x01, 0x1e, 0xa2, 0x54, 0x09, 0x92, 0x14, 0xc9, 0x64, 0x50, 0xa6, 0x4a, 0x60, 0x8c, 0x7a,
0x9a, 0xb7, 0x40, 0xd2, 0x80, 0x84, 0x19, 0x5f, 0xa0, 0x5c, 0x28, 0x09, 0xce, 0x93, 0x2c, 0xa0,
0xfb, 0x0d, 0x8f, 0xd1, 0x79, 0x6d, 0xda, 0x95, 0x05, 0xe7, 0x40, 0x2c, 0x9c, 0xda, 0x01, 0xe9,
0x15, 0xc9, 0x24, 0x2b, 0x87, 0xbf, 0xf0, 0x8b, 0xda, 0x01, 0x7e, 0x44, 0x79, 0x6d, 0xf4, 0x52,
0x49, 0xd2, 0x2f, 0x92, 0xc9, 0xd9, 0xed, 0x98, 0x9e, 0x4c, 0x4c, 0xe7, 0x8d, 0xa9, 0xca, 0xbd,
0xac, 0x33, 0x68, 0xf8, 0x16, 0xac, 0x23, 0x79, 0x91, 0xfd, 0xc9, 0x20, 0xca, 0xba, 0x58, 0x9e,
0x4b, 0x47, 0xfe, 0x15, 0x59, 0x17, 0xab, 0x9b, 0xf1, 0x3d, 0x42, 0xb5, 0x05, 0xee, 0x41, 0x2c,
0xb8, 0x27, 0xff, 0xc3, 0x65, 0x23, 0x1a, 0xab, 0xa3, 0x87, 0xea, 0xe8, 0xeb, 0xa1, 0xba, 0x72,
0xb0, 0x67, 0x3f, 0xf9, 0xf9, 0xfb, 0xc7, 0x9b, 0x54, 0xfe, 0x73, 0x5d, 0xd1, 0xda, 0xb4, 0x2c,
0xde, 0x32, 0x8d, 0xbf, 0x91, 0x66, 0x2a, 0x41, 0x07, 0x39, 0x3b, 0xf9, 0xb4, 0x87, 0x23, 0xb0,
0xca, 0x83, 0xf4, 0xee, 0x27, 0x00, 0x00, 0xff, 0xff, 0xb9, 0xfc, 0xfe, 0xdb, 0x44, 0x02, 0x00,
0x00,
}

519
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/image_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,519 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/image_service.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type ListImagesRequest struct {
// ID of the registry to list Docker images in.
//
// [registry_id] is ignored if a [ListImagesRequest.repository_name] is specified in the request.
//
// To get the registry ID use a [RegistryService.List] request.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
// Name of the repository to list Docker images in.
//
// To get the repository name use a [RepositoryService.List] request.
RepositoryName string `protobuf:"bytes,2,opt,name=repository_name,json=repositoryName,proto3" json:"repository_name,omitempty"`
// ID of the folder to list Docker images in.
//
// [folder_id] is ignored if a [ListImagesRequest.repository_name] or a [ListImagesRequest.registry_id] are specified in the request.
//
// To get the folder ID use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,7,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListImagesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListImagesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
// The expression must specify:
// 1. The field name. Currently you can use filtering only on [Image.name] field.
// 2. An operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
// 3. The value. Must be a maximum of 256 characters and match the regular expression `[a-z0-9]+(?:[._-][a-z0-9]+)*(/([a-z0-9]+(?:[._-][a-z0-9]+)*))`.
Filter string `protobuf:"bytes,5,opt,name=filter,proto3" json:"filter,omitempty"`
OrderBy string `protobuf:"bytes,6,opt,name=order_by,json=orderBy,proto3" json:"order_by,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListImagesRequest) Reset() { *m = ListImagesRequest{} }
func (m *ListImagesRequest) String() string { return proto.CompactTextString(m) }
func (*ListImagesRequest) ProtoMessage() {}
func (*ListImagesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_image_service_181142b342f3b95f, []int{0}
}
func (m *ListImagesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListImagesRequest.Unmarshal(m, b)
}
func (m *ListImagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListImagesRequest.Marshal(b, m, deterministic)
}
func (dst *ListImagesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListImagesRequest.Merge(dst, src)
}
func (m *ListImagesRequest) XXX_Size() int {
return xxx_messageInfo_ListImagesRequest.Size(m)
}
func (m *ListImagesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListImagesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListImagesRequest proto.InternalMessageInfo
func (m *ListImagesRequest) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
func (m *ListImagesRequest) GetRepositoryName() string {
if m != nil {
return m.RepositoryName
}
return ""
}
func (m *ListImagesRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListImagesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListImagesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListImagesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
func (m *ListImagesRequest) GetOrderBy() string {
if m != nil {
return m.OrderBy
}
return ""
}
type ListImagesResponse struct {
// List of Image resources.
Images []*Image `protobuf:"bytes,1,rep,name=images,proto3" json:"images,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListImagesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListImagesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListImagesResponse) Reset() { *m = ListImagesResponse{} }
func (m *ListImagesResponse) String() string { return proto.CompactTextString(m) }
func (*ListImagesResponse) ProtoMessage() {}
func (*ListImagesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_image_service_181142b342f3b95f, []int{1}
}
func (m *ListImagesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListImagesResponse.Unmarshal(m, b)
}
func (m *ListImagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListImagesResponse.Marshal(b, m, deterministic)
}
func (dst *ListImagesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListImagesResponse.Merge(dst, src)
}
func (m *ListImagesResponse) XXX_Size() int {
return xxx_messageInfo_ListImagesResponse.Size(m)
}
func (m *ListImagesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListImagesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListImagesResponse proto.InternalMessageInfo
func (m *ListImagesResponse) GetImages() []*Image {
if m != nil {
return m.Images
}
return nil
}
func (m *ListImagesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type GetImageRequest struct {
// ID of the Docker image resource to return.
//
// To get the Docker image ID use a [ImageService.List] request.
ImageId string `protobuf:"bytes,1,opt,name=image_id,json=imageId,proto3" json:"image_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetImageRequest) Reset() { *m = GetImageRequest{} }
func (m *GetImageRequest) String() string { return proto.CompactTextString(m) }
func (*GetImageRequest) ProtoMessage() {}
func (*GetImageRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_image_service_181142b342f3b95f, []int{2}
}
func (m *GetImageRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetImageRequest.Unmarshal(m, b)
}
func (m *GetImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetImageRequest.Marshal(b, m, deterministic)
}
func (dst *GetImageRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetImageRequest.Merge(dst, src)
}
func (m *GetImageRequest) XXX_Size() int {
return xxx_messageInfo_GetImageRequest.Size(m)
}
func (m *GetImageRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetImageRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetImageRequest proto.InternalMessageInfo
func (m *GetImageRequest) GetImageId() string {
if m != nil {
return m.ImageId
}
return ""
}
type DeleteImageRequest struct {
// ID of the Docker image to delete.
//
// To get Docker image ID use a [ImageService.List] request.
ImageId string `protobuf:"bytes,1,opt,name=image_id,json=imageId,proto3" json:"image_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteImageRequest) Reset() { *m = DeleteImageRequest{} }
func (m *DeleteImageRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteImageRequest) ProtoMessage() {}
func (*DeleteImageRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_image_service_181142b342f3b95f, []int{3}
}
func (m *DeleteImageRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteImageRequest.Unmarshal(m, b)
}
func (m *DeleteImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteImageRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteImageRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteImageRequest.Merge(dst, src)
}
func (m *DeleteImageRequest) XXX_Size() int {
return xxx_messageInfo_DeleteImageRequest.Size(m)
}
func (m *DeleteImageRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteImageRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteImageRequest proto.InternalMessageInfo
func (m *DeleteImageRequest) GetImageId() string {
if m != nil {
return m.ImageId
}
return ""
}
type DeleteImageMetadata struct {
// ID of the Docker image that is being deleted.
ImageId string `protobuf:"bytes,1,opt,name=image_id,json=imageId,proto3" json:"image_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteImageMetadata) Reset() { *m = DeleteImageMetadata{} }
func (m *DeleteImageMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteImageMetadata) ProtoMessage() {}
func (*DeleteImageMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_image_service_181142b342f3b95f, []int{4}
}
func (m *DeleteImageMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteImageMetadata.Unmarshal(m, b)
}
func (m *DeleteImageMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteImageMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteImageMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteImageMetadata.Merge(dst, src)
}
func (m *DeleteImageMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteImageMetadata.Size(m)
}
func (m *DeleteImageMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteImageMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteImageMetadata proto.InternalMessageInfo
func (m *DeleteImageMetadata) GetImageId() string {
if m != nil {
return m.ImageId
}
return ""
}
func init() {
proto.RegisterType((*ListImagesRequest)(nil), "yandex.cloud.containerregistry.v1.ListImagesRequest")
proto.RegisterType((*ListImagesResponse)(nil), "yandex.cloud.containerregistry.v1.ListImagesResponse")
proto.RegisterType((*GetImageRequest)(nil), "yandex.cloud.containerregistry.v1.GetImageRequest")
proto.RegisterType((*DeleteImageRequest)(nil), "yandex.cloud.containerregistry.v1.DeleteImageRequest")
proto.RegisterType((*DeleteImageMetadata)(nil), "yandex.cloud.containerregistry.v1.DeleteImageMetadata")
}
// 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
// ImageServiceClient is the client API for ImageService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ImageServiceClient interface {
// Retrieves the list of Image resources in the specified registry or repository.
List(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error)
// Returns the specified Image resource.
//
// To get the list of available Image resources, make a [List] request.
Get(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*Image, error)
// Deletes the specified Docker image.
Delete(ctx context.Context, in *DeleteImageRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type imageServiceClient struct {
cc *grpc.ClientConn
}
func NewImageServiceClient(cc *grpc.ClientConn) ImageServiceClient {
return &imageServiceClient{cc}
}
func (c *imageServiceClient) List(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) {
out := new(ListImagesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.ImageService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *imageServiceClient) Get(ctx context.Context, in *GetImageRequest, opts ...grpc.CallOption) (*Image, error) {
out := new(Image)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.ImageService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *imageServiceClient) Delete(ctx context.Context, in *DeleteImageRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.ImageService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ImageServiceServer is the server API for ImageService service.
type ImageServiceServer interface {
// Retrieves the list of Image resources in the specified registry or repository.
List(context.Context, *ListImagesRequest) (*ListImagesResponse, error)
// Returns the specified Image resource.
//
// To get the list of available Image resources, make a [List] request.
Get(context.Context, *GetImageRequest) (*Image, error)
// Deletes the specified Docker image.
Delete(context.Context, *DeleteImageRequest) (*operation.Operation, error)
}
func RegisterImageServiceServer(s *grpc.Server, srv ImageServiceServer) {
s.RegisterService(&_ImageService_serviceDesc, srv)
}
func _ImageService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListImagesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ImageServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.ImageService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ImageServiceServer).List(ctx, req.(*ListImagesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ImageService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetImageRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ImageServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.ImageService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ImageServiceServer).Get(ctx, req.(*GetImageRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ImageService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteImageRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ImageServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.ImageService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ImageServiceServer).Delete(ctx, req.(*DeleteImageRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ImageService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.containerregistry.v1.ImageService",
HandlerType: (*ImageServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "List",
Handler: _ImageService_List_Handler,
},
{
MethodName: "Get",
Handler: _ImageService_Get_Handler,
},
{
MethodName: "Delete",
Handler: _ImageService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/containerregistry/v1/image_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/image_service.proto", fileDescriptor_image_service_181142b342f3b95f)
}
var fileDescriptor_image_service_181142b342f3b95f = []byte{
// 667 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4b, 0x6f, 0xd3, 0x4c,
0x14, 0x95, 0x9b, 0x34, 0x4d, 0xa6, 0xfd, 0xbe, 0x8a, 0x41, 0x48, 0x26, 0xa2, 0xa2, 0xb5, 0x68,
0xeb, 0x04, 0xfc, 0x2a, 0x74, 0x41, 0x69, 0x55, 0x14, 0x40, 0x55, 0x24, 0x5e, 0x72, 0x91, 0x10,
0x54, 0x55, 0x70, 0xe2, 0x5b, 0x33, 0xc2, 0xf1, 0x18, 0x7b, 0x12, 0x35, 0xe5, 0xb1, 0x60, 0x99,
0x2d, 0x62, 0xc3, 0xcf, 0xe0, 0x37, 0x20, 0xb5, 0x6b, 0xf8, 0x0b, 0x2c, 0x58, 0x22, 0x96, 0xac,
0x90, 0x67, 0x92, 0x34, 0x0f, 0xd4, 0x06, 0x76, 0x96, 0xcf, 0x3d, 0x67, 0xce, 0xbd, 0x67, 0xe6,
0xa2, 0xd5, 0x96, 0x13, 0xb8, 0xb0, 0x6f, 0xd4, 0x7c, 0xda, 0x70, 0x8d, 0x1a, 0x0d, 0x98, 0x43,
0x02, 0x88, 0x22, 0xf0, 0x48, 0xcc, 0xa2, 0x96, 0xd1, 0xb4, 0x0c, 0x52, 0x77, 0x3c, 0xa8, 0xc4,
0x10, 0x35, 0x49, 0x0d, 0xf4, 0x30, 0xa2, 0x8c, 0xe2, 0x05, 0x41, 0xd3, 0x39, 0x4d, 0x1f, 0xa1,
0xe9, 0x4d, 0x2b, 0x9f, 0xef, 0x28, 0x3b, 0x21, 0x31, 0x68, 0x08, 0x91, 0xc3, 0x08, 0x0d, 0x04,
0x3d, 0xaf, 0x8d, 0x79, 0x6a, 0xa7, 0x7c, 0x69, 0xa0, 0xbc, 0x27, 0x36, 0x22, 0x3b, 0x37, 0x50,
0xd7, 0x74, 0x7c, 0xe2, 0xf6, 0xc3, 0x17, 0x3c, 0x4a, 0x3d, 0x1f, 0xb8, 0x23, 0x27, 0x08, 0x28,
0xe3, 0x60, 0x2c, 0x50, 0xe5, 0xc7, 0x04, 0x3a, 0x73, 0x97, 0xc4, 0xac, 0x9c, 0x1c, 0x1c, 0xdb,
0xf0, 0xb2, 0x01, 0x31, 0xc3, 0x05, 0x34, 0xdd, 0x75, 0x55, 0x21, 0xae, 0x2c, 0xcd, 0x4b, 0x6a,
0xae, 0x94, 0x6d, 0x1f, 0x59, 0xe9, 0xf5, 0x8d, 0x55, 0xd3, 0x46, 0x5d, 0xb0, 0xec, 0x62, 0x1f,
0xcd, 0x46, 0x10, 0xd2, 0x98, 0x30, 0x1a, 0xb5, 0x2a, 0x81, 0x53, 0x07, 0x79, 0x82, 0x97, 0xdf,
0xfa, 0x79, 0x68, 0x6d, 0xbe, 0xde, 0x71, 0xb4, 0x03, 0x53, 0xbb, 0xbe, 0x7b, 0x59, 0xdd, 0x5c,
0xdb, 0xd1, 0x2b, 0xda, 0x6e, 0xef, 0x47, 0xa1, 0xa8, 0x1a, 0xea, 0x49, 0x70, 0xa1, 0x50, 0xb4,
0xff, 0x3f, 0xd6, 0xbe, 0xef, 0xd4, 0x01, 0x2f, 0xa2, 0xdc, 0x1e, 0xf5, 0x5d, 0x88, 0x12, 0x5b,
0x53, 0x43, 0xb6, 0xb2, 0x02, 0x2a, 0xbb, 0x78, 0x19, 0xe5, 0x42, 0x1e, 0x1f, 0x39, 0x00, 0x39,
0x35, 0x2f, 0xa9, 0xa9, 0x12, 0xfa, 0x75, 0x68, 0x65, 0xd6, 0x37, 0x2c, 0xd3, 0x34, 0xed, 0x6c,
0x02, 0x6e, 0x93, 0x03, 0xc0, 0x2a, 0x42, 0xbc, 0x90, 0xd1, 0x17, 0x10, 0xc8, 0x69, 0x2e, 0x98,
0x6b, 0x1f, 0x59, 0x93, 0xbc, 0xd2, 0xe6, 0x2a, 0x8f, 0x12, 0x0c, 0x2b, 0x28, 0xb3, 0x47, 0x7c,
0x06, 0x91, 0x3c, 0xc9, 0xab, 0x50, 0xfb, 0xa8, 0xa7, 0xd7, 0x41, 0xf0, 0x25, 0x94, 0xa5, 0x51,
0x62, 0xae, 0xda, 0x92, 0x33, 0xc3, 0x5a, 0x53, 0x1c, 0x2a, 0xb5, 0x94, 0xb7, 0x08, 0xf7, 0x4f,
0x3c, 0x0e, 0x69, 0x10, 0x03, 0xbe, 0x89, 0x32, 0x3c, 0xfc, 0x58, 0x96, 0xe6, 0x53, 0xea, 0xf4,
0x8a, 0xaa, 0x9f, 0x7a, 0xd9, 0x74, 0x2e, 0x61, 0x77, 0x78, 0x78, 0x09, 0xcd, 0x06, 0xb0, 0xcf,
0x2a, 0x7d, 0x0d, 0xf1, 0x24, 0xec, 0xff, 0x92, 0xdf, 0x0f, 0xbb, 0x9d, 0x28, 0x6b, 0x68, 0x76,
0x0b, 0xc4, 0xf1, 0xdd, 0xbc, 0x97, 0x51, 0x56, 0xdc, 0xf7, 0x5e, 0xd8, 0x33, 0xdf, 0x0f, 0x2d,
0xa9, 0x37, 0xd9, 0x29, 0x8e, 0x96, 0x5d, 0x65, 0x03, 0xe1, 0xdb, 0xe0, 0x03, 0x83, 0x7f, 0xa3,
0x9b, 0xe8, 0x6c, 0x1f, 0xfd, 0x1e, 0x30, 0xc7, 0x75, 0x98, 0x83, 0xcf, 0x0f, 0xf3, 0x7b, 0x8c,
0x95, 0x76, 0x1a, 0xcd, 0xf0, 0xe2, 0x6d, 0xf1, 0x12, 0xf1, 0x47, 0x09, 0xa5, 0x93, 0xf1, 0xe1,
0x6b, 0x63, 0x0c, 0x68, 0xe4, 0x66, 0xe7, 0x57, 0xff, 0x92, 0x25, 0xd2, 0x51, 0x16, 0xdf, 0x7d,
0xfd, 0xf6, 0x7e, 0xe2, 0x22, 0x9e, 0x3b, 0x7e, 0xb6, 0xda, 0xc8, 0xbb, 0x8d, 0xf1, 0x07, 0x09,
0xa5, 0xb6, 0x80, 0xe1, 0x95, 0x31, 0x4e, 0x19, 0xca, 0x20, 0x3f, 0x76, 0xe0, 0x8a, 0xc9, 0xcd,
0x14, 0xb1, 0x7a, 0xa2, 0x19, 0xe3, 0x55, 0x77, 0xa6, 0x6f, 0xf0, 0x67, 0x09, 0x65, 0xc4, 0xe0,
0xf1, 0x38, 0x03, 0x18, 0x8d, 0x38, 0xbf, 0x30, 0x48, 0x3b, 0xde, 0x41, 0x0f, 0xba, 0x5f, 0xca,
0xb3, 0x4f, 0x5f, 0x8a, 0x57, 0xfe, 0x1c, 0xf0, 0x39, 0xb1, 0x83, 0xc4, 0xce, 0xa9, 0x36, 0xf6,
0xf4, 0x3b, 0xf5, 0x90, 0xb5, 0x44, 0x1b, 0xc5, 0xb1, 0xdb, 0x28, 0x3d, 0x79, 0xfa, 0xd8, 0x23,
0xec, 0x79, 0xa3, 0xaa, 0xd7, 0x68, 0xdd, 0x10, 0x86, 0x34, 0xb1, 0xf6, 0x3c, 0xaa, 0x79, 0x10,
0x70, 0x7d, 0xe3, 0xd4, 0x35, 0x7b, 0x63, 0xe4, 0x67, 0x35, 0xc3, 0xa9, 0x57, 0x7f, 0x07, 0x00,
0x00, 0xff, 0xff, 0xa8, 0xf4, 0x0e, 0x50, 0x1a, 0x06, 0x00, 0x00,
}

176
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/registry.pb.go generated vendored Normal file
View File

@ -0,0 +1,176 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/registry.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Registry_Status int32
const (
Registry_STATUS_UNSPECIFIED Registry_Status = 0
// Registry is being created.
Registry_CREATING Registry_Status = 1
// Registry is ready to use.
Registry_ACTIVE Registry_Status = 2
// Registry is being deleted.
Registry_DELETING Registry_Status = 3
)
var Registry_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "ACTIVE",
3: "DELETING",
}
var Registry_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"ACTIVE": 2,
"DELETING": 3,
}
func (x Registry_Status) String() string {
return proto.EnumName(Registry_Status_name, int32(x))
}
func (Registry_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_registry_101b7c4fe5ef1589, []int{0, 0}
}
// A Registry resource. For more information, see [Registry](/docs/cloud/containerregistry/registry).
type Registry struct {
// Output only. ID of the registry.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the registry belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Name of the registry.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Output only. Status of the registry.
Status Registry_Status `protobuf:"varint,4,opt,name=status,proto3,enum=yandex.cloud.containerregistry.v1.Registry_Status" json:"status,omitempty"`
// Output only. Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Resource labels as `key:value` pairs. Мaximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Registry) Reset() { *m = Registry{} }
func (m *Registry) String() string { return proto.CompactTextString(m) }
func (*Registry) ProtoMessage() {}
func (*Registry) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_101b7c4fe5ef1589, []int{0}
}
func (m *Registry) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Registry.Unmarshal(m, b)
}
func (m *Registry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Registry.Marshal(b, m, deterministic)
}
func (dst *Registry) XXX_Merge(src proto.Message) {
xxx_messageInfo_Registry.Merge(dst, src)
}
func (m *Registry) XXX_Size() int {
return xxx_messageInfo_Registry.Size(m)
}
func (m *Registry) XXX_DiscardUnknown() {
xxx_messageInfo_Registry.DiscardUnknown(m)
}
var xxx_messageInfo_Registry proto.InternalMessageInfo
func (m *Registry) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Registry) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Registry) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Registry) GetStatus() Registry_Status {
if m != nil {
return m.Status
}
return Registry_STATUS_UNSPECIFIED
}
func (m *Registry) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Registry) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func init() {
proto.RegisterType((*Registry)(nil), "yandex.cloud.containerregistry.v1.Registry")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.containerregistry.v1.Registry.LabelsEntry")
proto.RegisterEnum("yandex.cloud.containerregistry.v1.Registry_Status", Registry_Status_name, Registry_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/registry.proto", fileDescriptor_registry_101b7c4fe5ef1589)
}
var fileDescriptor_registry_101b7c4fe5ef1589 = []byte{
// 388 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x6f, 0x94, 0x40,
0x14, 0xc6, 0x05, 0x5a, 0xb2, 0xfb, 0xd6, 0x34, 0x64, 0x62, 0x0c, 0x59, 0x0f, 0x62, 0x4f, 0x5c,
0x3a, 0x63, 0xf1, 0xa0, 0xd5, 0x13, 0x6e, 0x51, 0x31, 0x4d, 0x35, 0x40, 0x35, 0x7a, 0xd9, 0x0c,
0xcc, 0x14, 0x89, 0xc0, 0x34, 0x30, 0x6c, 0xe4, 0x3f, 0xf2, 0xcf, 0x34, 0x9d, 0x81, 0xc4, 0x64,
0x0f, 0x9b, 0xde, 0x1e, 0xdf, 0xe3, 0xf7, 0xe6, 0x7d, 0x5f, 0x1e, 0xbc, 0x1c, 0x69, 0xcb, 0xf8,
0x1f, 0x52, 0xd4, 0x62, 0x60, 0xa4, 0x10, 0xad, 0xa4, 0x55, 0xcb, 0xbb, 0x8e, 0x97, 0x55, 0x2f,
0xbb, 0x91, 0xec, 0xce, 0xc9, 0x5c, 0xe3, 0xbb, 0x4e, 0x48, 0x81, 0x5e, 0x68, 0x02, 0x2b, 0x02,
0xef, 0x11, 0x78, 0x77, 0xbe, 0x7e, 0x5e, 0x0a, 0x51, 0xd6, 0x9c, 0x28, 0x20, 0x1f, 0x6e, 0x89,
0xac, 0x1a, 0xde, 0x4b, 0xda, 0xdc, 0xe9, 0x19, 0xa7, 0x7f, 0x2d, 0x58, 0x24, 0x13, 0x80, 0x4e,
0xc0, 0xac, 0x98, 0x6b, 0x78, 0x86, 0xbf, 0x4c, 0xcc, 0x8a, 0xa1, 0x67, 0xb0, 0xbc, 0x15, 0x35,
0xe3, 0xdd, 0xb6, 0x62, 0xae, 0xa9, 0xe4, 0x85, 0x16, 0x62, 0x86, 0x10, 0x1c, 0xb5, 0xb4, 0xe1,
0xae, 0xa5, 0x74, 0x55, 0xa3, 0xcf, 0x60, 0xf7, 0x92, 0xca, 0xa1, 0x77, 0x8f, 0x3c, 0xc3, 0x3f,
0x09, 0x02, 0x7c, 0x70, 0x45, 0x3c, 0xbf, 0x8e, 0x53, 0x45, 0x26, 0xd3, 0x04, 0x74, 0x01, 0x50,
0x74, 0x9c, 0x4a, 0xce, 0xb6, 0x54, 0xba, 0xc7, 0x9e, 0xe1, 0xaf, 0x82, 0x35, 0xd6, 0x7e, 0xf0,
0xec, 0x07, 0x67, 0xb3, 0x9f, 0x64, 0x39, 0xfd, 0x1d, 0x4a, 0xf4, 0x05, 0xec, 0x9a, 0xe6, 0xbc,
0xee, 0x5d, 0xdb, 0xb3, 0xfc, 0x55, 0xf0, 0xfa, 0x21, 0x6b, 0x5c, 0x29, 0x32, 0x6a, 0x65, 0x37,
0x26, 0xd3, 0x98, 0xf5, 0x05, 0xac, 0xfe, 0x93, 0x91, 0x03, 0xd6, 0x6f, 0x3e, 0x4e, 0x41, 0xdd,
0x97, 0xe8, 0x09, 0x1c, 0xef, 0x68, 0x3d, 0xf0, 0x29, 0x25, 0xfd, 0xf1, 0xd6, 0x7c, 0x63, 0x9c,
0x7e, 0x02, 0x5b, 0x1b, 0x43, 0x4f, 0x01, 0xa5, 0x59, 0x98, 0xdd, 0xa4, 0xdb, 0x9b, 0xeb, 0xf4,
0x6b, 0xb4, 0x89, 0x3f, 0xc4, 0xd1, 0xa5, 0xf3, 0x08, 0x3d, 0x86, 0xc5, 0x26, 0x89, 0xc2, 0x2c,
0xbe, 0xfe, 0xe8, 0x18, 0x08, 0xc0, 0x0e, 0x37, 0x59, 0xfc, 0x2d, 0x72, 0xcc, 0xfb, 0xce, 0x65,
0x74, 0x15, 0xa9, 0x8e, 0xf5, 0xfe, 0xc7, 0xcf, 0xef, 0x65, 0x25, 0x7f, 0x0d, 0x39, 0x2e, 0x44,
0x43, 0xb4, 0xa3, 0x33, 0x7d, 0x2d, 0xa5, 0x38, 0x2b, 0x79, 0xab, 0x42, 0x21, 0x07, 0xcf, 0xe8,
0xdd, 0x9e, 0x98, 0xdb, 0x0a, 0x7d, 0xf5, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x07, 0x78, 0x95, 0xaa,
0x84, 0x02, 0x00, 0x00,
}

785
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/registry_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,785 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/registry_service.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import field_mask "google.golang.org/genproto/protobuf/field_mask"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetRegistryRequest struct {
// ID of the Registry resource to return.
//
// To get the registry ID use a [RegistryService.List] request.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRegistryRequest) Reset() { *m = GetRegistryRequest{} }
func (m *GetRegistryRequest) String() string { return proto.CompactTextString(m) }
func (*GetRegistryRequest) ProtoMessage() {}
func (*GetRegistryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{0}
}
func (m *GetRegistryRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetRegistryRequest.Unmarshal(m, b)
}
func (m *GetRegistryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetRegistryRequest.Marshal(b, m, deterministic)
}
func (dst *GetRegistryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetRegistryRequest.Merge(dst, src)
}
func (m *GetRegistryRequest) XXX_Size() int {
return xxx_messageInfo_GetRegistryRequest.Size(m)
}
func (m *GetRegistryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetRegistryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetRegistryRequest proto.InternalMessageInfo
func (m *GetRegistryRequest) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
type ListRegistriesRequest struct {
// ID of the folder to list registries in.
//
// To get the folder ID use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListRegistriesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListRegistriesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
// The expression must specify:
// 1. The field name. Currently you can use filtering only on [Registry.name] field.
// 2. An operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
// 3. Value or a list of values to compare against the values of the field.
Filter string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRegistriesRequest) Reset() { *m = ListRegistriesRequest{} }
func (m *ListRegistriesRequest) String() string { return proto.CompactTextString(m) }
func (*ListRegistriesRequest) ProtoMessage() {}
func (*ListRegistriesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{1}
}
func (m *ListRegistriesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRegistriesRequest.Unmarshal(m, b)
}
func (m *ListRegistriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRegistriesRequest.Marshal(b, m, deterministic)
}
func (dst *ListRegistriesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRegistriesRequest.Merge(dst, src)
}
func (m *ListRegistriesRequest) XXX_Size() int {
return xxx_messageInfo_ListRegistriesRequest.Size(m)
}
func (m *ListRegistriesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListRegistriesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListRegistriesRequest proto.InternalMessageInfo
func (m *ListRegistriesRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListRegistriesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListRegistriesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListRegistriesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
type ListRegistriesResponse struct {
// List of Registry resources.
Registries []*Registry `protobuf:"bytes,1,rep,name=registries,proto3" json:"registries,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListRegistriesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListRegistriesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRegistriesResponse) Reset() { *m = ListRegistriesResponse{} }
func (m *ListRegistriesResponse) String() string { return proto.CompactTextString(m) }
func (*ListRegistriesResponse) ProtoMessage() {}
func (*ListRegistriesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{2}
}
func (m *ListRegistriesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRegistriesResponse.Unmarshal(m, b)
}
func (m *ListRegistriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRegistriesResponse.Marshal(b, m, deterministic)
}
func (dst *ListRegistriesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRegistriesResponse.Merge(dst, src)
}
func (m *ListRegistriesResponse) XXX_Size() int {
return xxx_messageInfo_ListRegistriesResponse.Size(m)
}
func (m *ListRegistriesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListRegistriesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListRegistriesResponse proto.InternalMessageInfo
func (m *ListRegistriesResponse) GetRegistries() []*Registry {
if m != nil {
return m.Registries
}
return nil
}
func (m *ListRegistriesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateRegistryRequest struct {
// ID of the folder to create a registry in.
//
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Name of the registry.
//
// There may be only one registry per folder.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// Resource labels as `key:value` pairs.
Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateRegistryRequest) Reset() { *m = CreateRegistryRequest{} }
func (m *CreateRegistryRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRegistryRequest) ProtoMessage() {}
func (*CreateRegistryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{3}
}
func (m *CreateRegistryRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateRegistryRequest.Unmarshal(m, b)
}
func (m *CreateRegistryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateRegistryRequest.Marshal(b, m, deterministic)
}
func (dst *CreateRegistryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateRegistryRequest.Merge(dst, src)
}
func (m *CreateRegistryRequest) XXX_Size() int {
return xxx_messageInfo_CreateRegistryRequest.Size(m)
}
func (m *CreateRegistryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateRegistryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateRegistryRequest proto.InternalMessageInfo
func (m *CreateRegistryRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *CreateRegistryRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateRegistryRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type CreateRegistryMetadata struct {
// ID of the registry that is being created.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateRegistryMetadata) Reset() { *m = CreateRegistryMetadata{} }
func (m *CreateRegistryMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateRegistryMetadata) ProtoMessage() {}
func (*CreateRegistryMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{4}
}
func (m *CreateRegistryMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateRegistryMetadata.Unmarshal(m, b)
}
func (m *CreateRegistryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateRegistryMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateRegistryMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateRegistryMetadata.Merge(dst, src)
}
func (m *CreateRegistryMetadata) XXX_Size() int {
return xxx_messageInfo_CreateRegistryMetadata.Size(m)
}
func (m *CreateRegistryMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateRegistryMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateRegistryMetadata proto.InternalMessageInfo
func (m *CreateRegistryMetadata) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
type UpdateRegistryRequest struct {
// ID of the Registry resource to update.
//
// To get the registry ID use a [RegistryService.List] request.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
// Field mask that specifies which fields of the Registry resource are going to be updated.
UpdateMask *field_mask.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
// Name of the registry.
//
// There may be only one registry per folder.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Resource labels as `key:value` pairs.
//
// Existing set of `labels` is completely replaced by the provided set.
Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateRegistryRequest) Reset() { *m = UpdateRegistryRequest{} }
func (m *UpdateRegistryRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateRegistryRequest) ProtoMessage() {}
func (*UpdateRegistryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{5}
}
func (m *UpdateRegistryRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateRegistryRequest.Unmarshal(m, b)
}
func (m *UpdateRegistryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateRegistryRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateRegistryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateRegistryRequest.Merge(dst, src)
}
func (m *UpdateRegistryRequest) XXX_Size() int {
return xxx_messageInfo_UpdateRegistryRequest.Size(m)
}
func (m *UpdateRegistryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateRegistryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateRegistryRequest proto.InternalMessageInfo
func (m *UpdateRegistryRequest) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
func (m *UpdateRegistryRequest) GetUpdateMask() *field_mask.FieldMask {
if m != nil {
return m.UpdateMask
}
return nil
}
func (m *UpdateRegistryRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UpdateRegistryRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type UpdateRegistryMetadata struct {
// ID of the Registry resource that is being updated.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateRegistryMetadata) Reset() { *m = UpdateRegistryMetadata{} }
func (m *UpdateRegistryMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateRegistryMetadata) ProtoMessage() {}
func (*UpdateRegistryMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{6}
}
func (m *UpdateRegistryMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateRegistryMetadata.Unmarshal(m, b)
}
func (m *UpdateRegistryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateRegistryMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateRegistryMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateRegistryMetadata.Merge(dst, src)
}
func (m *UpdateRegistryMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateRegistryMetadata.Size(m)
}
func (m *UpdateRegistryMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateRegistryMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateRegistryMetadata proto.InternalMessageInfo
func (m *UpdateRegistryMetadata) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
type DeleteRegistryRequest struct {
// ID of the registry to delete.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteRegistryRequest) Reset() { *m = DeleteRegistryRequest{} }
func (m *DeleteRegistryRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteRegistryRequest) ProtoMessage() {}
func (*DeleteRegistryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{7}
}
func (m *DeleteRegistryRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteRegistryRequest.Unmarshal(m, b)
}
func (m *DeleteRegistryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteRegistryRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteRegistryRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteRegistryRequest.Merge(dst, src)
}
func (m *DeleteRegistryRequest) XXX_Size() int {
return xxx_messageInfo_DeleteRegistryRequest.Size(m)
}
func (m *DeleteRegistryRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteRegistryRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteRegistryRequest proto.InternalMessageInfo
func (m *DeleteRegistryRequest) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
type DeleteRegistryMetadata struct {
// ID of the registry that is being deleted.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteRegistryMetadata) Reset() { *m = DeleteRegistryMetadata{} }
func (m *DeleteRegistryMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteRegistryMetadata) ProtoMessage() {}
func (*DeleteRegistryMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_registry_service_a571e9cda88c3d56, []int{8}
}
func (m *DeleteRegistryMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteRegistryMetadata.Unmarshal(m, b)
}
func (m *DeleteRegistryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteRegistryMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteRegistryMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteRegistryMetadata.Merge(dst, src)
}
func (m *DeleteRegistryMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteRegistryMetadata.Size(m)
}
func (m *DeleteRegistryMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteRegistryMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteRegistryMetadata proto.InternalMessageInfo
func (m *DeleteRegistryMetadata) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
func init() {
proto.RegisterType((*GetRegistryRequest)(nil), "yandex.cloud.containerregistry.v1.GetRegistryRequest")
proto.RegisterType((*ListRegistriesRequest)(nil), "yandex.cloud.containerregistry.v1.ListRegistriesRequest")
proto.RegisterType((*ListRegistriesResponse)(nil), "yandex.cloud.containerregistry.v1.ListRegistriesResponse")
proto.RegisterType((*CreateRegistryRequest)(nil), "yandex.cloud.containerregistry.v1.CreateRegistryRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.containerregistry.v1.CreateRegistryRequest.LabelsEntry")
proto.RegisterType((*CreateRegistryMetadata)(nil), "yandex.cloud.containerregistry.v1.CreateRegistryMetadata")
proto.RegisterType((*UpdateRegistryRequest)(nil), "yandex.cloud.containerregistry.v1.UpdateRegistryRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.containerregistry.v1.UpdateRegistryRequest.LabelsEntry")
proto.RegisterType((*UpdateRegistryMetadata)(nil), "yandex.cloud.containerregistry.v1.UpdateRegistryMetadata")
proto.RegisterType((*DeleteRegistryRequest)(nil), "yandex.cloud.containerregistry.v1.DeleteRegistryRequest")
proto.RegisterType((*DeleteRegistryMetadata)(nil), "yandex.cloud.containerregistry.v1.DeleteRegistryMetadata")
}
// 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
// RegistryServiceClient is the client API for RegistryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RegistryServiceClient interface {
// Returns the specified Registry resource.
//
// To get the list of available Registry resources, make a [List] request.
Get(ctx context.Context, in *GetRegistryRequest, opts ...grpc.CallOption) (*Registry, error)
// Retrieves the list of Registry resources in the specified folder.
List(ctx context.Context, in *ListRegistriesRequest, opts ...grpc.CallOption) (*ListRegistriesResponse, error)
// Creates a registry in the specified folder.
Create(ctx context.Context, in *CreateRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Updates the specified registry.
Update(ctx context.Context, in *UpdateRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified registry.
Delete(ctx context.Context, in *DeleteRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type registryServiceClient struct {
cc *grpc.ClientConn
}
func NewRegistryServiceClient(cc *grpc.ClientConn) RegistryServiceClient {
return &registryServiceClient{cc}
}
func (c *registryServiceClient) Get(ctx context.Context, in *GetRegistryRequest, opts ...grpc.CallOption) (*Registry, error) {
out := new(Registry)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RegistryService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *registryServiceClient) List(ctx context.Context, in *ListRegistriesRequest, opts ...grpc.CallOption) (*ListRegistriesResponse, error) {
out := new(ListRegistriesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RegistryService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *registryServiceClient) Create(ctx context.Context, in *CreateRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RegistryService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *registryServiceClient) Update(ctx context.Context, in *UpdateRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RegistryService/Update", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *registryServiceClient) Delete(ctx context.Context, in *DeleteRegistryRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RegistryService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RegistryServiceServer is the server API for RegistryService service.
type RegistryServiceServer interface {
// Returns the specified Registry resource.
//
// To get the list of available Registry resources, make a [List] request.
Get(context.Context, *GetRegistryRequest) (*Registry, error)
// Retrieves the list of Registry resources in the specified folder.
List(context.Context, *ListRegistriesRequest) (*ListRegistriesResponse, error)
// Creates a registry in the specified folder.
Create(context.Context, *CreateRegistryRequest) (*operation.Operation, error)
// Updates the specified registry.
Update(context.Context, *UpdateRegistryRequest) (*operation.Operation, error)
// Deletes the specified registry.
Delete(context.Context, *DeleteRegistryRequest) (*operation.Operation, error)
}
func RegisterRegistryServiceServer(s *grpc.Server, srv RegistryServiceServer) {
s.RegisterService(&_RegistryService_serviceDesc, srv)
}
func _RegistryService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRegistryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RegistryServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RegistryService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RegistryServiceServer).Get(ctx, req.(*GetRegistryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RegistryService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListRegistriesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RegistryServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RegistryService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RegistryServiceServer).List(ctx, req.(*ListRegistriesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RegistryService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRegistryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RegistryServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RegistryService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RegistryServiceServer).Create(ctx, req.(*CreateRegistryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RegistryService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateRegistryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RegistryServiceServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RegistryService/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RegistryServiceServer).Update(ctx, req.(*UpdateRegistryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RegistryService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteRegistryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RegistryServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RegistryService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RegistryServiceServer).Delete(ctx, req.(*DeleteRegistryRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RegistryService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.containerregistry.v1.RegistryService",
HandlerType: (*RegistryServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _RegistryService_Get_Handler,
},
{
MethodName: "List",
Handler: _RegistryService_List_Handler,
},
{
MethodName: "Create",
Handler: _RegistryService_Create_Handler,
},
{
MethodName: "Update",
Handler: _RegistryService_Update_Handler,
},
{
MethodName: "Delete",
Handler: _RegistryService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/containerregistry/v1/registry_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/registry_service.proto", fileDescriptor_registry_service_a571e9cda88c3d56)
}
var fileDescriptor_registry_service_a571e9cda88c3d56 = []byte{
// 885 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x96, 0xcf, 0x8f, 0xdb, 0x44,
0x14, 0xc7, 0xe5, 0x75, 0x6a, 0x36, 0x2f, 0xa0, 0x56, 0x23, 0x52, 0x45, 0x16, 0x15, 0xbb, 0x46,
0x5a, 0xb6, 0x01, 0xdb, 0xf1, 0xb6, 0xbb, 0x6c, 0xfa, 0x43, 0x48, 0xe9, 0x2f, 0x55, 0xb4, 0x02,
0xb9, 0x20, 0x04, 0xab, 0x2a, 0xcc, 0xae, 0x27, 0x61, 0x88, 0x63, 0x07, 0x7b, 0x12, 0x35, 0x29,
0xbd, 0xf4, 0xb8, 0x12, 0x27, 0xc4, 0x91, 0x0b, 0x07, 0xfe, 0x80, 0xbd, 0xed, 0x5f, 0x90, 0x5c,
0x29, 0xfc, 0x09, 0x1c, 0x38, 0xf7, 0xc8, 0x09, 0x79, 0xc6, 0x4e, 0xe3, 0x8d, 0xa3, 0x38, 0xe5,
0xc2, 0x6d, 0xec, 0xf7, 0xde, 0xd7, 0x9f, 0x37, 0x6f, 0xde, 0x1b, 0xc3, 0xfe, 0x10, 0x7b, 0x0e,
0x79, 0x62, 0x1e, 0xb9, 0x7e, 0xdf, 0x31, 0x8f, 0x7c, 0x8f, 0x61, 0xea, 0x91, 0x20, 0x20, 0x6d,
0x1a, 0xb2, 0x60, 0x68, 0x0e, 0x2c, 0x33, 0x59, 0x37, 0x43, 0x12, 0x0c, 0xe8, 0x11, 0x31, 0x7a,
0x81, 0xcf, 0x7c, 0xb4, 0x29, 0x22, 0x0d, 0x1e, 0x69, 0xcc, 0x45, 0x1a, 0x03, 0x4b, 0x55, 0x63,
0x71, 0xdc, 0xa3, 0xa6, 0xdf, 0x23, 0x01, 0x66, 0xd4, 0xf7, 0x44, 0xb8, 0x5a, 0xcb, 0xff, 0xe1,
0x38, 0x62, 0x2b, 0x15, 0x31, 0xd5, 0x9b, 0x53, 0xbe, 0x94, 0xf2, 0x1b, 0x60, 0x97, 0x3a, 0xb3,
0xe6, 0x8d, 0xb6, 0xef, 0xb7, 0x5d, 0x62, 0xf2, 0xa7, 0xc3, 0x7e, 0xcb, 0x6c, 0x51, 0xe2, 0x3a,
0xcd, 0x2e, 0x0e, 0x3b, 0xb1, 0xc7, 0x3b, 0xb1, 0x47, 0x84, 0x8d, 0x3d, 0xcf, 0x67, 0x3c, 0x3c,
0x14, 0x56, 0xed, 0x16, 0xa0, 0x7b, 0x84, 0xd9, 0x31, 0x9b, 0x4d, 0xbe, 0xef, 0x93, 0x90, 0x21,
0x1d, 0x4a, 0xd3, 0x7d, 0xa2, 0x4e, 0x45, 0xda, 0x90, 0xb6, 0x8b, 0x8d, 0x37, 0xff, 0x1e, 0x5b,
0xd2, 0xf1, 0xc4, 0x2a, 0xdc, 0xb8, 0xb9, 0x5b, 0xb3, 0x21, 0x71, 0xb8, 0xef, 0x68, 0xa7, 0x12,
0x94, 0x1f, 0xd0, 0x30, 0x91, 0xa1, 0x24, 0x4c, 0x84, 0x2e, 0x43, 0xb1, 0xe5, 0xbb, 0x0e, 0x09,
0x16, 0xc9, 0xac, 0x0b, 0xf3, 0x7d, 0x07, 0xbd, 0x0f, 0xc5, 0x1e, 0x6e, 0x93, 0x66, 0x48, 0x47,
0xa4, 0xb2, 0xb6, 0x21, 0x6d, 0xcb, 0x0d, 0xf8, 0x67, 0x6c, 0x29, 0x37, 0x6e, 0x5a, 0xb5, 0x5a,
0xcd, 0x5e, 0x8f, 0x8c, 0x8f, 0xe8, 0x88, 0xa0, 0x6d, 0x00, 0xee, 0xc8, 0xfc, 0x0e, 0xf1, 0x2a,
0x32, 0x17, 0x2d, 0x1e, 0x4f, 0xac, 0x73, 0xdc, 0xd3, 0xe6, 0x2a, 0x9f, 0x47, 0x36, 0xa4, 0x81,
0xd2, 0xa2, 0x2e, 0x23, 0x41, 0xa5, 0xc0, 0xbd, 0xe0, 0x78, 0x32, 0xd5, 0x8b, 0x2d, 0xda, 0x8f,
0x12, 0x5c, 0x3c, 0xcb, 0x1e, 0xf6, 0x7c, 0x2f, 0x24, 0xe8, 0x13, 0x48, 0x92, 0xa4, 0x24, 0xac,
0x48, 0x1b, 0xf2, 0x76, 0x69, 0xe7, 0x03, 0x63, 0xe9, 0x41, 0x31, 0xa6, 0xbb, 0x39, 0x13, 0x8e,
0xb6, 0xe0, 0xbc, 0x47, 0x9e, 0xb0, 0xe6, 0x0c, 0x7a, 0x94, 0x64, 0xd1, 0x7e, 0x2b, 0x7a, 0xfd,
0x59, 0xc2, 0xac, 0xfd, 0xb9, 0x06, 0xe5, 0x5b, 0x01, 0xc1, 0x8c, 0x9c, 0x2d, 0xca, 0x0a, 0x7b,
0xb9, 0x0b, 0x05, 0x0f, 0x77, 0xc5, 0x36, 0x16, 0x1b, 0x9b, 0x2f, 0xc7, 0xd6, 0xa5, 0x1f, 0x0e,
0xb0, 0x3e, 0x7a, 0x7c, 0xa0, 0x63, 0x7d, 0x54, 0xd3, 0xeb, 0x8f, 0x9f, 0x5a, 0x1f, 0xee, 0x59,
0xcf, 0x0e, 0xe2, 0x27, 0x9b, 0xbb, 0xa3, 0x5f, 0x24, 0x50, 0x5c, 0x7c, 0x48, 0xdc, 0xb0, 0x22,
0xf3, 0x6c, 0x6f, 0xe7, 0xc8, 0x36, 0x13, 0xd6, 0x78, 0xc0, 0x65, 0xee, 0x78, 0x2c, 0x18, 0x36,
0x3e, 0x7e, 0x39, 0xb6, 0x4a, 0x07, 0x7a, 0xb3, 0xa6, 0xd7, 0x23, 0x86, 0xea, 0x73, 0x0e, 0xbc,
0x77, 0x55, 0x80, 0xef, 0x5d, 0x39, 0x99, 0x58, 0x8a, 0x5a, 0xb0, 0x74, 0xbe, 0x42, 0xe8, 0x42,
0x4c, 0x3a, 0xf5, 0xb7, 0x63, 0x28, 0xb5, 0x0e, 0xa5, 0x19, 0x5d, 0x74, 0x01, 0xe4, 0x0e, 0x19,
0x8a, 0xad, 0xb0, 0xa3, 0x25, 0x7a, 0x1b, 0xce, 0x0d, 0xb0, 0xdb, 0x8f, 0x13, 0xb7, 0xc5, 0xc3,
0xb5, 0xb5, 0x7d, 0x49, 0xab, 0xc3, 0xc5, 0x34, 0xe8, 0x43, 0xc2, 0xb0, 0x83, 0x19, 0x46, 0xef,
0x66, 0x9c, 0xf5, 0xd4, 0xe9, 0xfe, 0x59, 0x86, 0xf2, 0x17, 0x3d, 0x27, 0xa3, 0x22, 0xab, 0xb5,
0x09, 0xba, 0x0e, 0xa5, 0x3e, 0xd7, 0xe1, 0xed, 0xc9, 0x19, 0x4b, 0x3b, 0xaa, 0x21, 0xfa, 0xd3,
0x48, 0x3a, 0xd8, 0xb8, 0x1b, 0x75, 0xf0, 0x43, 0x1c, 0x76, 0x6c, 0x10, 0xee, 0xd1, 0x7a, 0x5a,
0x52, 0xf9, 0xb5, 0x4b, 0x5a, 0xc8, 0x5d, 0xd2, 0xcc, 0x6c, 0xff, 0x8f, 0x25, 0x4d, 0x83, 0xe6,
0x2f, 0xe9, 0x5d, 0x28, 0xdf, 0x26, 0x2e, 0xf9, 0xaf, 0x15, 0x8d, 0x10, 0xd2, 0x3a, 0xb9, 0x11,
0x76, 0x4e, 0xdf, 0x80, 0xf3, 0x49, 0xd4, 0x23, 0x71, 0x15, 0xa1, 0x5f, 0x25, 0x90, 0xef, 0x11,
0x86, 0x76, 0x73, 0xd4, 0x68, 0x7e, 0x6a, 0xab, 0xab, 0xcc, 0x26, 0xed, 0xa3, 0xe7, 0x7f, 0xfc,
0xf5, 0xd3, 0x9a, 0x85, 0xcc, 0x57, 0xb7, 0x95, 0x9e, 0x71, 0x5d, 0x51, 0x12, 0x9a, 0x4f, 0x67,
0x32, 0x79, 0x86, 0x7e, 0x93, 0xa0, 0x10, 0x0d, 0x4c, 0xb4, 0x9f, 0xe3, 0x73, 0x99, 0xb7, 0x82,
0x5a, 0x7f, 0x8d, 0x48, 0x31, 0x93, 0xb5, 0xcb, 0x1c, 0xfb, 0x3d, 0xb4, 0xb9, 0x14, 0x1b, 0x9d,
0x4a, 0xa0, 0x88, 0x9e, 0xcf, 0x85, 0x9a, 0x39, 0xc7, 0xd4, 0xcd, 0x74, 0xe4, 0xab, 0xdb, 0xf9,
0xd3, 0x64, 0xa5, 0xd9, 0x27, 0x2f, 0xaa, 0xda, 0xc2, 0xf1, 0xb2, 0x9e, 0xbc, 0xe1, 0xe0, 0x5b,
0xda, 0x72, 0xf0, 0x6b, 0x52, 0x15, 0x8d, 0x25, 0x50, 0xc4, 0xe1, 0xce, 0xc5, 0x9e, 0xd9, 0xb0,
0x79, 0xd8, 0xbf, 0x11, 0xec, 0x0b, 0xfa, 0x28, 0xcd, 0x7e, 0x75, 0x67, 0xd5, 0xb3, 0x12, 0x65,
0xf2, 0xbb, 0x04, 0x8a, 0xe8, 0x91, 0x5c, 0x99, 0x64, 0xb6, 0x65, 0x9e, 0x4c, 0xbe, 0x3b, 0x79,
0x51, 0x35, 0x17, 0xb6, 0x63, 0xf9, 0xec, 0x90, 0xbd, 0xd3, 0xed, 0x31, 0x91, 0x96, 0x55, 0x5d,
0x35, 0xad, 0xc6, 0x57, 0x5f, 0x7f, 0xd9, 0xa6, 0xec, 0xdb, 0xfe, 0xa1, 0x71, 0xe4, 0x77, 0x4d,
0x81, 0xa6, 0x8b, 0x1f, 0xb4, 0xb6, 0xaf, 0xb7, 0x89, 0xc7, 0x3f, 0x63, 0x2e, 0xfd, 0x27, 0xbc,
0x3e, 0xf7, 0xf2, 0x50, 0xe1, 0xa1, 0x57, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xbe, 0x24, 0x8d,
0x20, 0xca, 0x0a, 0x00, 0x00,
}

82
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/repository.pb.go generated vendored Normal file
View File

@ -0,0 +1,82 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/repository.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A Repository resource. For more information, see [Repository](/docs/cloud/container-registry/repository).
type Repository struct {
// Name of the repository.
// The name is unique within the registry.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Repository) Reset() { *m = Repository{} }
func (m *Repository) String() string { return proto.CompactTextString(m) }
func (*Repository) ProtoMessage() {}
func (*Repository) Descriptor() ([]byte, []int) {
return fileDescriptor_repository_956a089f454b4ee5, []int{0}
}
func (m *Repository) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Repository.Unmarshal(m, b)
}
func (m *Repository) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Repository.Marshal(b, m, deterministic)
}
func (dst *Repository) XXX_Merge(src proto.Message) {
xxx_messageInfo_Repository.Merge(dst, src)
}
func (m *Repository) XXX_Size() int {
return xxx_messageInfo_Repository.Size(m)
}
func (m *Repository) XXX_DiscardUnknown() {
xxx_messageInfo_Repository.DiscardUnknown(m)
}
var xxx_messageInfo_Repository proto.InternalMessageInfo
func (m *Repository) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*Repository)(nil), "yandex.cloud.containerregistry.v1.Repository")
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/repository.proto", fileDescriptor_repository_956a089f454b4ee5)
}
var fileDescriptor_repository_956a089f454b4ee5 = []byte{
// 153 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0xaa, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc,
0x4b, 0x2d, 0x2a, 0x4a, 0x4d, 0xcf, 0x2c, 0x2e, 0x29, 0xaa, 0xd4, 0x2f, 0x33, 0xd4, 0x2f, 0x4a,
0x2d, 0xc8, 0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52,
0x84, 0xe8, 0xd1, 0x03, 0xeb, 0xd1, 0xc3, 0xd0, 0xa3, 0x57, 0x66, 0xa8, 0xa4, 0xc0, 0xc5, 0x15,
0x04, 0xd7, 0x26, 0x24, 0xc4, 0xc5, 0x92, 0x97, 0x98, 0x9b, 0x2a, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1,
0x19, 0x04, 0x66, 0x3b, 0x45, 0x46, 0x85, 0xa7, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7,
0xe7, 0xea, 0x43, 0x4c, 0xd4, 0x85, 0xb8, 0x22, 0x3d, 0x5f, 0x37, 0x3d, 0x35, 0x0f, 0x6c, 0x97,
0x3e, 0x41, 0xe7, 0x59, 0x63, 0x08, 0x26, 0xb1, 0x81, 0xb5, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff,
0xff, 0x1d, 0x25, 0xf5, 0x56, 0xdc, 0x00, 0x00, 0x00,
}

293
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1/repository_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,293 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/containerregistry/v1/repository_service.proto
package containerregistry // import "github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type ListRepositoriesRequest struct {
// ID of the registry to list repositories in.
//
// To get the registry ID use a [RegistryService.List] request.
RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"`
// ID of the folder to list registries in.
//
// [folder_id] is ignored if a [ListImagesRequest.registry_id] is specified in the request.
//
// To get the folder ID use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,6,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListRepositoriesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListRepositoriesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
// The expression must specify:
// 1. The field name. Currently you can use filtering only on [Repository.name] field.
// 2. An operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
// 3. Value or a list of values to compare against the values of the field.
Filter string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
OrderBy string `protobuf:"bytes,5,opt,name=order_by,json=orderBy,proto3" json:"order_by,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRepositoriesRequest) Reset() { *m = ListRepositoriesRequest{} }
func (m *ListRepositoriesRequest) String() string { return proto.CompactTextString(m) }
func (*ListRepositoriesRequest) ProtoMessage() {}
func (*ListRepositoriesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_repository_service_a3b7f42aed43c753, []int{0}
}
func (m *ListRepositoriesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRepositoriesRequest.Unmarshal(m, b)
}
func (m *ListRepositoriesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRepositoriesRequest.Marshal(b, m, deterministic)
}
func (dst *ListRepositoriesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRepositoriesRequest.Merge(dst, src)
}
func (m *ListRepositoriesRequest) XXX_Size() int {
return xxx_messageInfo_ListRepositoriesRequest.Size(m)
}
func (m *ListRepositoriesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListRepositoriesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListRepositoriesRequest proto.InternalMessageInfo
func (m *ListRepositoriesRequest) GetRegistryId() string {
if m != nil {
return m.RegistryId
}
return ""
}
func (m *ListRepositoriesRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListRepositoriesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListRepositoriesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListRepositoriesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
func (m *ListRepositoriesRequest) GetOrderBy() string {
if m != nil {
return m.OrderBy
}
return ""
}
type ListRepositoriesResponse struct {
// List of Repository resources.
Repositories []*Repository `protobuf:"bytes,1,rep,name=repositories,proto3" json:"repositories,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListRepositoriesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListRepositoriesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRepositoriesResponse) Reset() { *m = ListRepositoriesResponse{} }
func (m *ListRepositoriesResponse) String() string { return proto.CompactTextString(m) }
func (*ListRepositoriesResponse) ProtoMessage() {}
func (*ListRepositoriesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_repository_service_a3b7f42aed43c753, []int{1}
}
func (m *ListRepositoriesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRepositoriesResponse.Unmarshal(m, b)
}
func (m *ListRepositoriesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRepositoriesResponse.Marshal(b, m, deterministic)
}
func (dst *ListRepositoriesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRepositoriesResponse.Merge(dst, src)
}
func (m *ListRepositoriesResponse) XXX_Size() int {
return xxx_messageInfo_ListRepositoriesResponse.Size(m)
}
func (m *ListRepositoriesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListRepositoriesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListRepositoriesResponse proto.InternalMessageInfo
func (m *ListRepositoriesResponse) GetRepositories() []*Repository {
if m != nil {
return m.Repositories
}
return nil
}
func (m *ListRepositoriesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*ListRepositoriesRequest)(nil), "yandex.cloud.containerregistry.v1.ListRepositoriesRequest")
proto.RegisterType((*ListRepositoriesResponse)(nil), "yandex.cloud.containerregistry.v1.ListRepositoriesResponse")
}
// 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
// RepositoryServiceClient is the client API for RepositoryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RepositoryServiceClient interface {
// Retrieves the list of Repository resources in the specified registry.
List(ctx context.Context, in *ListRepositoriesRequest, opts ...grpc.CallOption) (*ListRepositoriesResponse, error)
}
type repositoryServiceClient struct {
cc *grpc.ClientConn
}
func NewRepositoryServiceClient(cc *grpc.ClientConn) RepositoryServiceClient {
return &repositoryServiceClient{cc}
}
func (c *repositoryServiceClient) List(ctx context.Context, in *ListRepositoriesRequest, opts ...grpc.CallOption) (*ListRepositoriesResponse, error) {
out := new(ListRepositoriesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.containerregistry.v1.RepositoryService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RepositoryServiceServer is the server API for RepositoryService service.
type RepositoryServiceServer interface {
// Retrieves the list of Repository resources in the specified registry.
List(context.Context, *ListRepositoriesRequest) (*ListRepositoriesResponse, error)
}
func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
s.RegisterService(&_RepositoryService_serviceDesc, srv)
}
func _RepositoryService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListRepositoriesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.containerregistry.v1.RepositoryService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).List(ctx, req.(*ListRepositoriesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RepositoryService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.containerregistry.v1.RepositoryService",
HandlerType: (*RepositoryServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "List",
Handler: _RepositoryService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/containerregistry/v1/repository_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/containerregistry/v1/repository_service.proto", fileDescriptor_repository_service_a3b7f42aed43c753)
}
var fileDescriptor_repository_service_a3b7f42aed43c753 = []byte{
// 460 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xbd, 0x8e, 0xd3, 0x40,
0x14, 0x85, 0xe5, 0x24, 0x1b, 0xe2, 0xbb, 0x20, 0xc4, 0x34, 0x58, 0x11, 0x48, 0x21, 0xb0, 0x10,
0x84, 0x62, 0xc7, 0x41, 0x34, 0xfb, 0xd3, 0xa4, 0x5b, 0x89, 0x02, 0xbc, 0x48, 0x08, 0x9a, 0xc8,
0x89, 0xef, 0x9a, 0x11, 0x66, 0xae, 0x99, 0x99, 0x44, 0xeb, 0x2d, 0xa9, 0x50, 0x5a, 0xc4, 0x5b,
0xf0, 0x14, 0x34, 0xa4, 0xe7, 0x15, 0x78, 0x0a, 0x2a, 0xe4, 0x99, 0xf5, 0xfe, 0x05, 0x14, 0xa0,
0x9d, 0x73, 0xce, 0x37, 0x77, 0xee, 0x1c, 0xd8, 0x2e, 0x62, 0x91, 0xe0, 0x51, 0x30, 0xcd, 0x68,
0x96, 0x04, 0x53, 0x12, 0x3a, 0xe6, 0x02, 0xa5, 0xc4, 0x94, 0x2b, 0x2d, 0x8b, 0x60, 0x1e, 0x06,
0x12, 0x73, 0x52, 0x5c, 0x93, 0x2c, 0xc6, 0x0a, 0xe5, 0x9c, 0x4f, 0xd1, 0xcf, 0x25, 0x69, 0x62,
0x77, 0x6c, 0xd6, 0x37, 0x59, 0x7f, 0x25, 0xeb, 0xcf, 0xc3, 0xf6, 0xf0, 0x5f, 0xf0, 0x16, 0xdb,
0xbe, 0x7d, 0x21, 0x33, 0x8f, 0x33, 0x9e, 0xc4, 0x9a, 0x93, 0x38, 0x91, 0x6f, 0xa5, 0x44, 0x69,
0x86, 0x41, 0x9c, 0xf3, 0x20, 0x16, 0x82, 0xb4, 0x11, 0x95, 0x55, 0xbb, 0x1f, 0x6b, 0x70, 0xf3,
0x29, 0x57, 0x3a, 0xaa, 0xa8, 0x1c, 0x55, 0x84, 0xef, 0x67, 0xa8, 0x34, 0x7b, 0x08, 0x9b, 0xd5,
0xc5, 0x63, 0x9e, 0x78, 0x4e, 0xc7, 0xe9, 0xb9, 0xa3, 0xd6, 0x62, 0x19, 0x36, 0x76, 0xf7, 0x9e,
0x0c, 0x22, 0xa8, 0xc4, 0xfd, 0x84, 0x6d, 0x81, 0x7b, 0x48, 0x59, 0x82, 0xb2, 0x34, 0x36, 0x2f,
0x19, 0x5b, 0x56, 0xda, 0x4f, 0xd8, 0x03, 0x70, 0xf3, 0x38, 0xc5, 0xb1, 0xe2, 0xc7, 0xe8, 0xd5,
0x3a, 0x4e, 0xaf, 0x3e, 0x82, 0x9f, 0xdf, 0xc2, 0xe6, 0xee, 0x5e, 0x38, 0x18, 0x0c, 0xa2, 0x56,
0x29, 0x1e, 0xf0, 0x63, 0x64, 0x3d, 0x00, 0x63, 0xd4, 0xf4, 0x16, 0x85, 0x57, 0x37, 0x40, 0x77,
0xb1, 0x0c, 0x37, 0x8c, 0x33, 0x32, 0x94, 0x17, 0xa5, 0xc6, 0xba, 0xd0, 0x3c, 0xe4, 0x99, 0x46,
0xe9, 0x35, 0x8c, 0x0b, 0x16, 0xcb, 0x53, 0xde, 0x89, 0xc2, 0xee, 0x41, 0x8b, 0x64, 0x39, 0xdc,
0xa4, 0xf0, 0x36, 0x2e, 0xb3, 0xae, 0x18, 0x69, 0x54, 0x74, 0x3f, 0x3b, 0xe0, 0xad, 0xae, 0x42,
0xe5, 0x24, 0x14, 0xb2, 0xe7, 0x70, 0x55, 0x9e, 0x3b, 0xf7, 0x9c, 0x4e, 0xbd, 0xb7, 0x39, 0xec,
0xfb, 0x6b, 0xbf, 0xd4, 0x3f, 0xc5, 0x15, 0xd1, 0x05, 0x04, 0xbb, 0x0f, 0xd7, 0x05, 0x1e, 0xe9,
0xf1, 0xb9, 0x87, 0x96, 0x2b, 0x71, 0xa3, 0x6b, 0xe5, 0xf1, 0xb3, 0xea, 0x85, 0xc3, 0xaf, 0x0e,
0xdc, 0x38, 0x83, 0x1c, 0xd8, 0x4a, 0xb1, 0x2f, 0x0e, 0x34, 0xca, 0x69, 0xd9, 0xf6, 0x5f, 0xcc,
0xf0, 0x87, 0x1f, 0x6e, 0xef, 0xfc, 0x57, 0xd6, 0xae, 0xa4, 0xfb, 0xe8, 0xc3, 0xf7, 0x1f, 0x9f,
0x6a, 0x5b, 0xec, 0xee, 0x59, 0x4f, 0xfb, 0xbf, 0x2d, 0x2a, 0x47, 0x35, 0x7a, 0xf5, 0xfa, 0x65,
0xca, 0xf5, 0x9b, 0xd9, 0xc4, 0x9f, 0xd2, 0xbb, 0xc0, 0xde, 0xda, 0xb7, 0x8d, 0x4d, 0xa9, 0x9f,
0xa2, 0x30, 0x75, 0x0c, 0xd6, 0xd6, 0x7f, 0x67, 0xe5, 0x70, 0xd2, 0x34, 0xd1, 0xc7, 0xbf, 0x02,
0x00, 0x00, 0xff, 0xff, 0xde, 0x4e, 0x2c, 0x46, 0x9b, 0x03, 0x00, 0x00,
}

87
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint/api_endpoint.pb.go generated vendored Normal file
View File

@ -0,0 +1,87 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/endpoint/api_endpoint.proto
package endpoint // import "github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
type ApiEndpoint struct {
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ApiEndpoint) Reset() { *m = ApiEndpoint{} }
func (m *ApiEndpoint) String() string { return proto.CompactTextString(m) }
func (*ApiEndpoint) ProtoMessage() {}
func (*ApiEndpoint) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_f9ce6e4a311495de, []int{0}
}
func (m *ApiEndpoint) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ApiEndpoint.Unmarshal(m, b)
}
func (m *ApiEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ApiEndpoint.Marshal(b, m, deterministic)
}
func (dst *ApiEndpoint) XXX_Merge(src proto.Message) {
xxx_messageInfo_ApiEndpoint.Merge(dst, src)
}
func (m *ApiEndpoint) XXX_Size() int {
return xxx_messageInfo_ApiEndpoint.Size(m)
}
func (m *ApiEndpoint) XXX_DiscardUnknown() {
xxx_messageInfo_ApiEndpoint.DiscardUnknown(m)
}
var xxx_messageInfo_ApiEndpoint proto.InternalMessageInfo
func (m *ApiEndpoint) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ApiEndpoint) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func init() {
proto.RegisterType((*ApiEndpoint)(nil), "yandex.cloud.endpoint.ApiEndpoint")
}
func init() {
proto.RegisterFile("yandex/cloud/endpoint/api_endpoint.proto", fileDescriptor_api_endpoint_f9ce6e4a311495de)
}
var fileDescriptor_api_endpoint_f9ce6e4a311495de = []byte{
// 152 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xa8, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xcd, 0x4b, 0x29, 0xc8, 0xcf, 0xcc,
0x2b, 0xd1, 0x4f, 0x2c, 0xc8, 0x8c, 0x87, 0x71, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x44,
0x21, 0x2a, 0xf5, 0xc0, 0x2a, 0xf5, 0x60, 0x92, 0x4a, 0xe6, 0x5c, 0xdc, 0x8e, 0x05, 0x99, 0xae,
0x50, 0xae, 0x10, 0x1f, 0x17, 0x53, 0x66, 0x8a, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x53,
0x66, 0x8a, 0x90, 0x04, 0x17, 0x7b, 0x62, 0x4a, 0x4a, 0x51, 0x6a, 0x71, 0xb1, 0x04, 0x13, 0x58,
0x10, 0xc6, 0x75, 0x72, 0x89, 0x72, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
0xd5, 0x87, 0x18, 0xae, 0x0b, 0x71, 0x46, 0x7a, 0xbe, 0x6e, 0x7a, 0x6a, 0x1e, 0xd8, 0x5a, 0x7d,
0xac, 0xee, 0xb3, 0x86, 0x31, 0x92, 0xd8, 0xc0, 0xaa, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff,
0x42, 0x6c, 0x3b, 0xb8, 0xc8, 0x00, 0x00, 0x00,
}

298
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint/api_endpoint_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,298 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/endpoint/api_endpoint_service.proto
package endpoint // import "github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetApiEndpointRequest struct {
ApiEndpointId string `protobuf:"bytes,1,opt,name=api_endpoint_id,json=apiEndpointId,proto3" json:"api_endpoint_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetApiEndpointRequest) Reset() { *m = GetApiEndpointRequest{} }
func (m *GetApiEndpointRequest) String() string { return proto.CompactTextString(m) }
func (*GetApiEndpointRequest) ProtoMessage() {}
func (*GetApiEndpointRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{0}
}
func (m *GetApiEndpointRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetApiEndpointRequest.Unmarshal(m, b)
}
func (m *GetApiEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetApiEndpointRequest.Marshal(b, m, deterministic)
}
func (dst *GetApiEndpointRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetApiEndpointRequest.Merge(dst, src)
}
func (m *GetApiEndpointRequest) XXX_Size() int {
return xxx_messageInfo_GetApiEndpointRequest.Size(m)
}
func (m *GetApiEndpointRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetApiEndpointRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetApiEndpointRequest proto.InternalMessageInfo
func (m *GetApiEndpointRequest) GetApiEndpointId() string {
if m != nil {
return m.ApiEndpointId
}
return ""
}
type ListApiEndpointsRequest struct {
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiEndpointsRequest) Reset() { *m = ListApiEndpointsRequest{} }
func (m *ListApiEndpointsRequest) String() string { return proto.CompactTextString(m) }
func (*ListApiEndpointsRequest) ProtoMessage() {}
func (*ListApiEndpointsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{1}
}
func (m *ListApiEndpointsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiEndpointsRequest.Unmarshal(m, b)
}
func (m *ListApiEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiEndpointsRequest.Marshal(b, m, deterministic)
}
func (dst *ListApiEndpointsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiEndpointsRequest.Merge(dst, src)
}
func (m *ListApiEndpointsRequest) XXX_Size() int {
return xxx_messageInfo_ListApiEndpointsRequest.Size(m)
}
func (m *ListApiEndpointsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiEndpointsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiEndpointsRequest proto.InternalMessageInfo
func (m *ListApiEndpointsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListApiEndpointsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListApiEndpointsResponse struct {
Endpoints []*ApiEndpoint `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiEndpointsResponse) Reset() { *m = ListApiEndpointsResponse{} }
func (m *ListApiEndpointsResponse) String() string { return proto.CompactTextString(m) }
func (*ListApiEndpointsResponse) ProtoMessage() {}
func (*ListApiEndpointsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{2}
}
func (m *ListApiEndpointsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiEndpointsResponse.Unmarshal(m, b)
}
func (m *ListApiEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiEndpointsResponse.Marshal(b, m, deterministic)
}
func (dst *ListApiEndpointsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiEndpointsResponse.Merge(dst, src)
}
func (m *ListApiEndpointsResponse) XXX_Size() int {
return xxx_messageInfo_ListApiEndpointsResponse.Size(m)
}
func (m *ListApiEndpointsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiEndpointsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiEndpointsResponse proto.InternalMessageInfo
func (m *ListApiEndpointsResponse) GetEndpoints() []*ApiEndpoint {
if m != nil {
return m.Endpoints
}
return nil
}
func (m *ListApiEndpointsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetApiEndpointRequest)(nil), "yandex.cloud.endpoint.GetApiEndpointRequest")
proto.RegisterType((*ListApiEndpointsRequest)(nil), "yandex.cloud.endpoint.ListApiEndpointsRequest")
proto.RegisterType((*ListApiEndpointsResponse)(nil), "yandex.cloud.endpoint.ListApiEndpointsResponse")
}
// 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
// ApiEndpointServiceClient is the client API for ApiEndpointService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApiEndpointServiceClient interface {
Get(ctx context.Context, in *GetApiEndpointRequest, opts ...grpc.CallOption) (*ApiEndpoint, error)
List(ctx context.Context, in *ListApiEndpointsRequest, opts ...grpc.CallOption) (*ListApiEndpointsResponse, error)
}
type apiEndpointServiceClient struct {
cc *grpc.ClientConn
}
func NewApiEndpointServiceClient(cc *grpc.ClientConn) ApiEndpointServiceClient {
return &apiEndpointServiceClient{cc}
}
func (c *apiEndpointServiceClient) Get(ctx context.Context, in *GetApiEndpointRequest, opts ...grpc.CallOption) (*ApiEndpoint, error) {
out := new(ApiEndpoint)
err := c.cc.Invoke(ctx, "/yandex.cloud.endpoint.ApiEndpointService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *apiEndpointServiceClient) List(ctx context.Context, in *ListApiEndpointsRequest, opts ...grpc.CallOption) (*ListApiEndpointsResponse, error) {
out := new(ListApiEndpointsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.endpoint.ApiEndpointService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ApiEndpointServiceServer is the server API for ApiEndpointService service.
type ApiEndpointServiceServer interface {
Get(context.Context, *GetApiEndpointRequest) (*ApiEndpoint, error)
List(context.Context, *ListApiEndpointsRequest) (*ListApiEndpointsResponse, error)
}
func RegisterApiEndpointServiceServer(s *grpc.Server, srv ApiEndpointServiceServer) {
s.RegisterService(&_ApiEndpointService_serviceDesc, srv)
}
func _ApiEndpointService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetApiEndpointRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiEndpointServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.endpoint.ApiEndpointService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiEndpointServiceServer).Get(ctx, req.(*GetApiEndpointRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ApiEndpointService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListApiEndpointsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiEndpointServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.endpoint.ApiEndpointService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiEndpointServiceServer).List(ctx, req.(*ListApiEndpointsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ApiEndpointService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.endpoint.ApiEndpointService",
HandlerType: (*ApiEndpointServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ApiEndpointService_Get_Handler,
},
{
MethodName: "List",
Handler: _ApiEndpointService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/endpoint/api_endpoint_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/endpoint/api_endpoint_service.proto", fileDescriptor_api_endpoint_service_3b852f01606ed782)
}
var fileDescriptor_api_endpoint_service_3b852f01606ed782 = []byte{
// 370 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x51, 0x4b, 0x2a, 0x41,
0x18, 0x65, 0xf5, 0x72, 0xb9, 0x7e, 0xf7, 0xca, 0x85, 0x01, 0x69, 0xd9, 0x2c, 0x64, 0x89, 0xf0,
0x21, 0x67, 0xc2, 0x1e, 0x7b, 0xa8, 0xa4, 0x90, 0xa0, 0x87, 0xd0, 0x7a, 0xe9, 0x65, 0x59, 0xdd,
0x8f, 0x6d, 0xc8, 0x66, 0x36, 0x67, 0x0c, 0x53, 0x7c, 0x89, 0x7e, 0x40, 0xd0, 0x4f, 0xeb, 0x2f,
0xf4, 0x43, 0x62, 0x67, 0xda, 0xb4, 0x54, 0xf2, 0x6d, 0xf7, 0x9b, 0x73, 0xce, 0x9c, 0x39, 0xe7,
0x83, 0xdd, 0x87, 0x50, 0x44, 0x38, 0x64, 0xdd, 0x9e, 0x1c, 0x44, 0x0c, 0x45, 0x94, 0x48, 0x2e,
0x34, 0x0b, 0x13, 0x1e, 0x64, 0x3f, 0x81, 0xc2, 0xfe, 0x3d, 0xef, 0x22, 0x4d, 0xfa, 0x52, 0x4b,
0x52, 0xb2, 0x0c, 0x6a, 0x18, 0x34, 0x03, 0x79, 0xe5, 0x58, 0xca, 0xb8, 0x87, 0x29, 0x93, 0x85,
0x42, 0x48, 0x1d, 0x6a, 0x2e, 0x85, 0xb2, 0x24, 0xaf, 0xfa, 0xf3, 0x35, 0x16, 0xe9, 0x1f, 0x40,
0xa9, 0x89, 0xfa, 0x28, 0xe1, 0x27, 0x1f, 0xf3, 0x16, 0xde, 0x0d, 0x50, 0x69, 0xb2, 0x0d, 0xff,
0xbf, 0xb8, 0xe2, 0x91, 0xeb, 0x54, 0x9c, 0x6a, 0xa1, 0x55, 0x0c, 0xa7, 0xe0, 0xd3, 0xc8, 0xbf,
0x84, 0xb5, 0x33, 0xae, 0x66, 0x15, 0x54, 0x26, 0xb1, 0x0e, 0x85, 0x24, 0x8c, 0x31, 0x50, 0x7c,
0x84, 0x86, 0x9c, 0x6f, 0xfd, 0x49, 0x07, 0x6d, 0x3e, 0x42, 0xb2, 0x01, 0x60, 0x0e, 0xb5, 0xbc,
0x41, 0xe1, 0xe6, 0x8c, 0xb4, 0x81, 0x5f, 0xa4, 0x03, 0xff, 0xc9, 0x01, 0x77, 0x5e, 0x57, 0x25,
0x52, 0x28, 0x24, 0x87, 0x50, 0xc8, 0x7c, 0x29, 0xd7, 0xa9, 0xe4, 0xab, 0x7f, 0xeb, 0x3e, 0x5d,
0x98, 0x13, 0x9d, 0x7d, 0xd9, 0x94, 0x94, 0xbe, 0x4e, 0xe0, 0x50, 0x07, 0x73, 0x16, 0x8a, 0xe9,
0xf8, 0x3c, 0xb3, 0x51, 0x7f, 0xce, 0x01, 0x99, 0x91, 0x68, 0xdb, 0x6a, 0xc8, 0x04, 0xf2, 0x4d,
0xd4, 0x64, 0x67, 0xc9, 0xa5, 0x0b, 0x13, 0xf5, 0x56, 0xb0, 0xe8, 0x6f, 0x3d, 0xbe, 0xbe, 0xbd,
0xe4, 0x36, 0x49, 0xf9, 0xb3, 0x34, 0xc5, 0xc6, 0xdf, 0x7a, 0x98, 0x90, 0x31, 0xfc, 0x4a, 0xb3,
0x21, 0x74, 0x89, 0xe2, 0x92, 0x42, 0x3c, 0xb6, 0x32, 0xde, 0x06, 0xed, 0x13, 0x63, 0xe7, 0x1f,
0x81, 0xa9, 0x9d, 0xc6, 0xf1, 0x55, 0x23, 0xe6, 0xfa, 0x7a, 0xd0, 0xa1, 0x5d, 0x79, 0xcb, 0xac,
0x60, 0xcd, 0x2e, 0x5a, 0x2c, 0x6b, 0x31, 0x0a, 0xb3, 0x58, 0x6c, 0xe1, 0x06, 0xee, 0x67, 0x1f,
0x9d, 0xdf, 0x06, 0xb5, 0xf7, 0x1e, 0x00, 0x00, 0xff, 0xff, 0x83, 0x68, 0x07, 0x93, 0x11, 0x03,
0x00, 0x00,
}

115
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/api_key.pb.go generated vendored Normal file
View File

@ -0,0 +1,115 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/api_key.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// An ApiKey resource.
type ApiKey struct {
// ID of the API Key.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the service account that the API key belongs to.
ServiceAccountId string `protobuf:"bytes,2,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Creation timestamp.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Description of the API key. 0-256 characters long.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ApiKey) Reset() { *m = ApiKey{} }
func (m *ApiKey) String() string { return proto.CompactTextString(m) }
func (*ApiKey) ProtoMessage() {}
func (*ApiKey) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_559895c00d20010c, []int{0}
}
func (m *ApiKey) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ApiKey.Unmarshal(m, b)
}
func (m *ApiKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ApiKey.Marshal(b, m, deterministic)
}
func (dst *ApiKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_ApiKey.Merge(dst, src)
}
func (m *ApiKey) XXX_Size() int {
return xxx_messageInfo_ApiKey.Size(m)
}
func (m *ApiKey) XXX_DiscardUnknown() {
xxx_messageInfo_ApiKey.DiscardUnknown(m)
}
var xxx_messageInfo_ApiKey proto.InternalMessageInfo
func (m *ApiKey) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ApiKey) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ApiKey) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *ApiKey) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ApiKey)(nil), "yandex.cloud.iam.v1.ApiKey")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/api_key.proto", fileDescriptor_api_key_559895c00d20010c)
}
var fileDescriptor_api_key_559895c00d20010c = []byte{
// 247 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xb1, 0x4b, 0xc4, 0x30,
0x14, 0x87, 0x69, 0x95, 0x83, 0xcb, 0x81, 0x48, 0x5c, 0xca, 0x2d, 0x56, 0xa7, 0x1b, 0xbc, 0x84,
0xd3, 0x49, 0x0e, 0x87, 0xba, 0x89, 0xdb, 0xe1, 0xe4, 0x52, 0xd2, 0xe4, 0x19, 0x1f, 0x5e, 0x9a,
0xd0, 0xbe, 0x16, 0xfb, 0xf7, 0xf8, 0x8f, 0x0a, 0xc9, 0x15, 0x1c, 0x5c, 0xf3, 0x7d, 0xe1, 0xe3,
0xfd, 0xd8, 0xcd, 0xa4, 0x5a, 0x03, 0xdf, 0x52, 0x1f, 0xfd, 0x60, 0x24, 0x2a, 0x27, 0xc7, 0x9d,
0x54, 0x01, 0xeb, 0x2f, 0x98, 0x44, 0xe8, 0x3c, 0x79, 0x7e, 0x95, 0x14, 0x11, 0x15, 0x81, 0xca,
0x89, 0x71, 0xb7, 0xbe, 0xb6, 0xde, 0xdb, 0x23, 0xc8, 0xa8, 0x34, 0xc3, 0x87, 0x24, 0x74, 0xd0,
0x93, 0x72, 0x21, 0xfd, 0xba, 0xfd, 0xc9, 0xd8, 0xa2, 0x0a, 0xf8, 0x0a, 0x13, 0xbf, 0x60, 0x39,
0x9a, 0x22, 0x2b, 0xb3, 0xcd, 0xf2, 0x90, 0xa3, 0xe1, 0x77, 0x8c, 0xf7, 0xd0, 0x8d, 0xa8, 0xa1,
0x56, 0x5a, 0xfb, 0xa1, 0xa5, 0x1a, 0x4d, 0x91, 0x47, 0x7e, 0x79, 0x22, 0x55, 0x02, 0x2f, 0x86,
0x3f, 0x32, 0xa6, 0x3b, 0x50, 0x04, 0xa6, 0x56, 0x54, 0x9c, 0x95, 0xd9, 0x66, 0x75, 0xbf, 0x16,
0x29, 0x2f, 0xe6, 0xbc, 0x78, 0x9b, 0xf3, 0x87, 0xe5, 0xc9, 0xae, 0x88, 0x97, 0x6c, 0x65, 0xa0,
0xd7, 0x1d, 0x06, 0x42, 0xdf, 0x16, 0xe7, 0xb1, 0xf0, 0xf7, 0xe9, 0xf9, 0xe9, 0x7d, 0x6f, 0x91,
0x3e, 0x87, 0x46, 0x68, 0xef, 0x64, 0x3a, 0x74, 0x9b, 0xb6, 0xb0, 0x7e, 0x6b, 0xa1, 0x8d, 0x01,
0xf9, 0xcf, 0x48, 0x7b, 0x54, 0xae, 0x59, 0x44, 0xfc, 0xf0, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xb3,
0x5f, 0xeb, 0x6a, 0x46, 0x01, 0x00, 0x00,
}

561
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/api_key_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,561 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/api_key_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetApiKeyRequest struct {
// ID of the API key to return.
// To get the API key ID, use a [ApiKeyService.List] request.
ApiKeyId string `protobuf:"bytes,1,opt,name=api_key_id,json=apiKeyId,proto3" json:"api_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetApiKeyRequest) Reset() { *m = GetApiKeyRequest{} }
func (m *GetApiKeyRequest) String() string { return proto.CompactTextString(m) }
func (*GetApiKeyRequest) ProtoMessage() {}
func (*GetApiKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{0}
}
func (m *GetApiKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetApiKeyRequest.Unmarshal(m, b)
}
func (m *GetApiKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetApiKeyRequest.Marshal(b, m, deterministic)
}
func (dst *GetApiKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetApiKeyRequest.Merge(dst, src)
}
func (m *GetApiKeyRequest) XXX_Size() int {
return xxx_messageInfo_GetApiKeyRequest.Size(m)
}
func (m *GetApiKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetApiKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetApiKeyRequest proto.InternalMessageInfo
func (m *GetApiKeyRequest) GetApiKeyId() string {
if m != nil {
return m.ApiKeyId
}
return ""
}
type ListApiKeysRequest struct {
// ID of the service account to list API keys for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListApiKeysResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token]
// to the [ListApiKeysResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiKeysRequest) Reset() { *m = ListApiKeysRequest{} }
func (m *ListApiKeysRequest) String() string { return proto.CompactTextString(m) }
func (*ListApiKeysRequest) ProtoMessage() {}
func (*ListApiKeysRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{1}
}
func (m *ListApiKeysRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiKeysRequest.Unmarshal(m, b)
}
func (m *ListApiKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiKeysRequest.Marshal(b, m, deterministic)
}
func (dst *ListApiKeysRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiKeysRequest.Merge(dst, src)
}
func (m *ListApiKeysRequest) XXX_Size() int {
return xxx_messageInfo_ListApiKeysRequest.Size(m)
}
func (m *ListApiKeysRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiKeysRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiKeysRequest proto.InternalMessageInfo
func (m *ListApiKeysRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ListApiKeysRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListApiKeysRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListApiKeysResponse struct {
// List of API keys.
ApiKeys []*ApiKey `protobuf:"bytes,1,rep,name=api_keys,json=apiKeys,proto3" json:"api_keys,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListApiKeysRequest.page_size], use
// the [next_page_token] as the value
// for the [ListApiKeysRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiKeysResponse) Reset() { *m = ListApiKeysResponse{} }
func (m *ListApiKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListApiKeysResponse) ProtoMessage() {}
func (*ListApiKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{2}
}
func (m *ListApiKeysResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiKeysResponse.Unmarshal(m, b)
}
func (m *ListApiKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiKeysResponse.Marshal(b, m, deterministic)
}
func (dst *ListApiKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiKeysResponse.Merge(dst, src)
}
func (m *ListApiKeysResponse) XXX_Size() int {
return xxx_messageInfo_ListApiKeysResponse.Size(m)
}
func (m *ListApiKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiKeysResponse proto.InternalMessageInfo
func (m *ListApiKeysResponse) GetApiKeys() []*ApiKey {
if m != nil {
return m.ApiKeys
}
return nil
}
func (m *ListApiKeysResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateApiKeyRequest struct {
// ID of the service account to create an API key for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Description of the API key.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateApiKeyRequest) Reset() { *m = CreateApiKeyRequest{} }
func (m *CreateApiKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateApiKeyRequest) ProtoMessage() {}
func (*CreateApiKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{3}
}
func (m *CreateApiKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateApiKeyRequest.Unmarshal(m, b)
}
func (m *CreateApiKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateApiKeyRequest.Marshal(b, m, deterministic)
}
func (dst *CreateApiKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateApiKeyRequest.Merge(dst, src)
}
func (m *CreateApiKeyRequest) XXX_Size() int {
return xxx_messageInfo_CreateApiKeyRequest.Size(m)
}
func (m *CreateApiKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateApiKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateApiKeyRequest proto.InternalMessageInfo
func (m *CreateApiKeyRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *CreateApiKeyRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
type CreateApiKeyResponse struct {
// ApiKey resource.
ApiKey *ApiKey `protobuf:"bytes,1,opt,name=api_key,json=apiKey,proto3" json:"api_key,omitempty"`
// Secret part of the API key. This secret key you may use in the requests for authentication.
Secret string `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateApiKeyResponse) Reset() { *m = CreateApiKeyResponse{} }
func (m *CreateApiKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateApiKeyResponse) ProtoMessage() {}
func (*CreateApiKeyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{4}
}
func (m *CreateApiKeyResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateApiKeyResponse.Unmarshal(m, b)
}
func (m *CreateApiKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateApiKeyResponse.Marshal(b, m, deterministic)
}
func (dst *CreateApiKeyResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateApiKeyResponse.Merge(dst, src)
}
func (m *CreateApiKeyResponse) XXX_Size() int {
return xxx_messageInfo_CreateApiKeyResponse.Size(m)
}
func (m *CreateApiKeyResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateApiKeyResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateApiKeyResponse proto.InternalMessageInfo
func (m *CreateApiKeyResponse) GetApiKey() *ApiKey {
if m != nil {
return m.ApiKey
}
return nil
}
func (m *CreateApiKeyResponse) GetSecret() string {
if m != nil {
return m.Secret
}
return ""
}
type DeleteApiKeyRequest struct {
// ID of the API key to delete.
// To get the API key ID, use a [ApiKeyService.List] request.
ApiKeyId string `protobuf:"bytes,1,opt,name=api_key_id,json=apiKeyId,proto3" json:"api_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteApiKeyRequest) Reset() { *m = DeleteApiKeyRequest{} }
func (m *DeleteApiKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteApiKeyRequest) ProtoMessage() {}
func (*DeleteApiKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_key_service_c31388470460ddf5, []int{5}
}
func (m *DeleteApiKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteApiKeyRequest.Unmarshal(m, b)
}
func (m *DeleteApiKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteApiKeyRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteApiKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteApiKeyRequest.Merge(dst, src)
}
func (m *DeleteApiKeyRequest) XXX_Size() int {
return xxx_messageInfo_DeleteApiKeyRequest.Size(m)
}
func (m *DeleteApiKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteApiKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteApiKeyRequest proto.InternalMessageInfo
func (m *DeleteApiKeyRequest) GetApiKeyId() string {
if m != nil {
return m.ApiKeyId
}
return ""
}
func init() {
proto.RegisterType((*GetApiKeyRequest)(nil), "yandex.cloud.iam.v1.GetApiKeyRequest")
proto.RegisterType((*ListApiKeysRequest)(nil), "yandex.cloud.iam.v1.ListApiKeysRequest")
proto.RegisterType((*ListApiKeysResponse)(nil), "yandex.cloud.iam.v1.ListApiKeysResponse")
proto.RegisterType((*CreateApiKeyRequest)(nil), "yandex.cloud.iam.v1.CreateApiKeyRequest")
proto.RegisterType((*CreateApiKeyResponse)(nil), "yandex.cloud.iam.v1.CreateApiKeyResponse")
proto.RegisterType((*DeleteApiKeyRequest)(nil), "yandex.cloud.iam.v1.DeleteApiKeyRequest")
}
// 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
// ApiKeyServiceClient is the client API for ApiKeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApiKeyServiceClient interface {
// Retrieves the list of API keys for the specified service account.
List(ctx context.Context, in *ListApiKeysRequest, opts ...grpc.CallOption) (*ListApiKeysResponse, error)
// Returns the specified API key.
//
// To get the list of available API keys, make a [List] request.
Get(ctx context.Context, in *GetApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error)
// Creates an API key for the specified service account.
Create(ctx context.Context, in *CreateApiKeyRequest, opts ...grpc.CallOption) (*CreateApiKeyResponse, error)
// Deletes the specified API key.
Delete(ctx context.Context, in *DeleteApiKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type apiKeyServiceClient struct {
cc *grpc.ClientConn
}
func NewApiKeyServiceClient(cc *grpc.ClientConn) ApiKeyServiceClient {
return &apiKeyServiceClient{cc}
}
func (c *apiKeyServiceClient) List(ctx context.Context, in *ListApiKeysRequest, opts ...grpc.CallOption) (*ListApiKeysResponse, error) {
out := new(ListApiKeysResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.ApiKeyService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *apiKeyServiceClient) Get(ctx context.Context, in *GetApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error) {
out := new(ApiKey)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.ApiKeyService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *apiKeyServiceClient) Create(ctx context.Context, in *CreateApiKeyRequest, opts ...grpc.CallOption) (*CreateApiKeyResponse, error) {
out := new(CreateApiKeyResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.ApiKeyService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *apiKeyServiceClient) Delete(ctx context.Context, in *DeleteApiKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.ApiKeyService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ApiKeyServiceServer is the server API for ApiKeyService service.
type ApiKeyServiceServer interface {
// Retrieves the list of API keys for the specified service account.
List(context.Context, *ListApiKeysRequest) (*ListApiKeysResponse, error)
// Returns the specified API key.
//
// To get the list of available API keys, make a [List] request.
Get(context.Context, *GetApiKeyRequest) (*ApiKey, error)
// Creates an API key for the specified service account.
Create(context.Context, *CreateApiKeyRequest) (*CreateApiKeyResponse, error)
// Deletes the specified API key.
Delete(context.Context, *DeleteApiKeyRequest) (*empty.Empty, error)
}
func RegisterApiKeyServiceServer(s *grpc.Server, srv ApiKeyServiceServer) {
s.RegisterService(&_ApiKeyService_serviceDesc, srv)
}
func _ApiKeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListApiKeysRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiKeyServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.ApiKeyService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiKeyServiceServer).List(ctx, req.(*ListApiKeysRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ApiKeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetApiKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiKeyServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.ApiKeyService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiKeyServiceServer).Get(ctx, req.(*GetApiKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ApiKeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateApiKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiKeyServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.ApiKeyService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiKeyServiceServer).Create(ctx, req.(*CreateApiKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ApiKeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteApiKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiKeyServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.ApiKeyService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiKeyServiceServer).Delete(ctx, req.(*DeleteApiKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ApiKeyService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.ApiKeyService",
HandlerType: (*ApiKeyServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "List",
Handler: _ApiKeyService_List_Handler,
},
{
MethodName: "Get",
Handler: _ApiKeyService_Get_Handler,
},
{
MethodName: "Create",
Handler: _ApiKeyService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _ApiKeyService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/api_key_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/api_key_service.proto", fileDescriptor_api_key_service_c31388470460ddf5)
}
var fileDescriptor_api_key_service_c31388470460ddf5 = []byte{
// 602 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0xcf, 0x4f, 0x13, 0x41,
0x14, 0xc7, 0xb3, 0x14, 0x4b, 0xfb, 0x90, 0x80, 0x53, 0x82, 0xcd, 0x82, 0x06, 0x37, 0x2a, 0x05,
0xc3, 0xfe, 0x40, 0xe1, 0x20, 0x60, 0x02, 0x6a, 0x08, 0xd1, 0x83, 0x29, 0x9e, 0xbc, 0x34, 0xc3,
0xee, 0xb3, 0x4e, 0x68, 0x77, 0xd6, 0xce, 0x6c, 0x43, 0x31, 0x5e, 0x3c, 0x72, 0xf5, 0x0f, 0xf0,
0xcf, 0x81, 0xbb, 0x7f, 0x81, 0x89, 0x07, 0xff, 0x06, 0x4f, 0x66, 0x67, 0xa6, 0x40, 0xeb, 0x0a,
0xea, 0x71, 0xf7, 0xbd, 0xf9, 0x7e, 0xdf, 0xe7, 0xbd, 0x99, 0x07, 0x8b, 0x3d, 0x1a, 0x47, 0x78,
0xe8, 0x85, 0x2d, 0x9e, 0x46, 0x1e, 0xa3, 0x6d, 0xaf, 0x1b, 0x78, 0x34, 0x61, 0x8d, 0x03, 0xec,
0x35, 0x04, 0x76, 0xba, 0x2c, 0x44, 0x37, 0xe9, 0x70, 0xc9, 0x49, 0x45, 0xa7, 0xba, 0x2a, 0xd5,
0x65, 0xb4, 0xed, 0x76, 0x03, 0x7b, 0xae, 0xc9, 0x79, 0xb3, 0x85, 0xd9, 0x11, 0x8f, 0xc6, 0x31,
0x97, 0x54, 0x32, 0x1e, 0x0b, 0x7d, 0xc4, 0x9e, 0x35, 0x51, 0xf5, 0xb5, 0x9f, 0xbe, 0xf5, 0xb0,
0x9d, 0xc8, 0x9e, 0x09, 0xde, 0xb9, 0xc4, 0xda, 0xa4, 0xdc, 0x1a, 0x48, 0xe9, 0xd2, 0x16, 0x8b,
0x94, 0xbe, 0x0e, 0x3b, 0x4f, 0x60, 0x6a, 0x07, 0xe5, 0x56, 0xc2, 0x5e, 0x60, 0xaf, 0x8e, 0xef,
0x53, 0x14, 0x92, 0x2c, 0x01, 0xf4, 0xcb, 0x67, 0x51, 0xd5, 0x9a, 0xb7, 0x6a, 0xe5, 0xed, 0xeb,
0x3f, 0x4e, 0x02, 0xeb, 0xf8, 0x34, 0x18, 0xdd, 0xd8, 0x5c, 0xf5, 0xeb, 0x25, 0xaa, 0x0e, 0xec,
0x46, 0xce, 0x17, 0x0b, 0xc8, 0x4b, 0x26, 0x8c, 0x82, 0xe8, 0x4b, 0xac, 0x01, 0x31, 0xe4, 0x0d,
0x1a, 0x86, 0x3c, 0x8d, 0xe5, 0xb9, 0x54, 0xe9, 0x4c, 0x66, 0xca, 0xe4, 0x6c, 0xe9, 0x94, 0xdd,
0x88, 0x2c, 0x40, 0x39, 0xa1, 0x4d, 0x6c, 0x08, 0x76, 0x84, 0xd5, 0x91, 0x79, 0xab, 0x56, 0xd8,
0x86, 0x9f, 0x27, 0x41, 0xd1, 0x5f, 0x0e, 0x7c, 0xdf, 0xaf, 0x97, 0xb2, 0xe0, 0x1e, 0x3b, 0x42,
0x52, 0x03, 0x50, 0x89, 0x92, 0x1f, 0x60, 0x5c, 0x2d, 0x28, 0xe1, 0xf2, 0xf1, 0x69, 0x70, 0x6d,
0x63, 0x33, 0xf0, 0xfd, 0xba, 0x52, 0x79, 0x9d, 0xc5, 0x9c, 0x14, 0x2a, 0x03, 0x05, 0x8a, 0x84,
0xc7, 0x02, 0xc9, 0x1a, 0x94, 0x0c, 0xa4, 0xa8, 0x5a, 0xf3, 0x85, 0xda, 0xf8, 0xca, 0xac, 0x9b,
0x33, 0x1d, 0xd7, 0xb4, 0x66, 0x4c, 0x13, 0x0b, 0x72, 0x1f, 0x26, 0x63, 0x3c, 0x94, 0x8d, 0x0b,
0xee, 0x59, 0x9d, 0xe5, 0xfa, 0x44, 0xf6, 0xfb, 0xd5, 0x99, 0xed, 0x11, 0x54, 0x9e, 0x76, 0x90,
0x4a, 0x1c, 0xec, 0xed, 0xff, 0x36, 0xe6, 0x01, 0x8c, 0x47, 0x28, 0xc2, 0x0e, 0x4b, 0xb2, 0xe1,
0x69, 0xcb, 0x3e, 0xf0, 0xca, 0xea, 0x5a, 0xfd, 0x62, 0xd4, 0x89, 0x60, 0x7a, 0xd0, 0xdb, 0x30,
0x3f, 0x82, 0x31, 0xc3, 0xac, 0x1c, 0xaf, 0x40, 0x2e, 0x6a, 0x64, 0x32, 0x03, 0x45, 0x81, 0x61,
0x07, 0xa5, 0x01, 0x35, 0x5f, 0xce, 0x16, 0x54, 0x9e, 0x61, 0x0b, 0x87, 0x09, 0xff, 0xe1, 0xf6,
0xac, 0x7c, 0x2b, 0xc0, 0x84, 0x3e, 0xbd, 0xa7, 0x81, 0x49, 0x07, 0x46, 0xb3, 0x69, 0x91, 0x85,
0xdc, 0xca, 0x7e, 0xbf, 0x69, 0x76, 0xed, 0xea, 0x44, 0x4d, 0xef, 0xdc, 0xfc, 0xf4, 0xf5, 0xfb,
0xe7, 0x91, 0x1b, 0x64, 0xf2, 0xc2, 0x43, 0x51, 0x23, 0xe5, 0x50, 0xd8, 0x41, 0x49, 0xee, 0xe5,
0x2a, 0x0d, 0xbf, 0x0e, 0xfb, 0xb2, 0x9e, 0x39, 0x77, 0x95, 0xc7, 0x6d, 0x32, 0x37, 0xe4, 0xe1,
0x7d, 0x38, 0xef, 0xc9, 0x47, 0xd2, 0x83, 0xa2, 0x9e, 0x0f, 0xc9, 0xaf, 0x3e, 0xe7, 0xe2, 0xd8,
0x8b, 0x7f, 0x91, 0x69, 0x40, 0x6d, 0x55, 0xc4, 0xb4, 0x33, 0x0c, 0xfa, 0xd8, 0x5a, 0x22, 0x09,
0x14, 0xf5, 0xd0, 0xfe, 0x60, 0x9d, 0x33, 0x51, 0x7b, 0xc6, 0xd5, 0x3b, 0xc8, 0xed, 0xef, 0x20,
0xf7, 0x79, 0xb6, 0x83, 0xfa, 0xb0, 0x4b, 0x97, 0xc2, 0x6e, 0x6f, 0xbe, 0x59, 0x6f, 0x32, 0xf9,
0x2e, 0xdd, 0x77, 0x43, 0xde, 0xf6, 0xb4, 0xe7, 0xb2, 0xde, 0x46, 0x4d, 0xbe, 0xdc, 0xc4, 0x58,
0xa9, 0x7a, 0x39, 0x9b, 0x6c, 0x9d, 0xd1, 0xf6, 0x7e, 0x51, 0x85, 0x1f, 0xfe, 0x0a, 0x00, 0x00,
0xff, 0xff, 0x77, 0x3b, 0x11, 0x86, 0x66, 0x05, 0x00, 0x00,
}

129
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility/access_key.pb.go generated vendored Normal file
View File

@ -0,0 +1,129 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/awscompatibility/access_key.proto
package awscompatibility // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// An access key.
// For more information, see [AWS-compatible access keys](/docs/iam/concepts/authorization/access-key).
type AccessKey struct {
// ID of the AccessKey resource.
// It is used to manage secret credentials: an access key ID and a secret access key.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the service account that the access key belongs to.
ServiceAccountId string `protobuf:"bytes,2,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Description of the access key. 0-256 characters long.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// ID of the access key.
// The key is AWS compatible.
KeyId string `protobuf:"bytes,5,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessKey) Reset() { *m = AccessKey{} }
func (m *AccessKey) String() string { return proto.CompactTextString(m) }
func (*AccessKey) ProtoMessage() {}
func (*AccessKey) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_262db7ab27be9a62, []int{0}
}
func (m *AccessKey) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessKey.Unmarshal(m, b)
}
func (m *AccessKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessKey.Marshal(b, m, deterministic)
}
func (dst *AccessKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessKey.Merge(dst, src)
}
func (m *AccessKey) XXX_Size() int {
return xxx_messageInfo_AccessKey.Size(m)
}
func (m *AccessKey) XXX_DiscardUnknown() {
xxx_messageInfo_AccessKey.DiscardUnknown(m)
}
var xxx_messageInfo_AccessKey proto.InternalMessageInfo
func (m *AccessKey) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *AccessKey) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *AccessKey) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *AccessKey) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *AccessKey) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func init() {
proto.RegisterType((*AccessKey)(nil), "yandex.cloud.iam.v1.awscompatibility.AccessKey")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/awscompatibility/access_key.proto", fileDescriptor_access_key_262db7ab27be9a62)
}
var fileDescriptor_access_key_262db7ab27be9a62 = []byte{
// 285 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0x41, 0x4b, 0xfb, 0x30,
0x18, 0xc6, 0xe9, 0xfe, 0xff, 0x0d, 0x96, 0x81, 0x48, 0x40, 0x28, 0xbb, 0x58, 0xc4, 0xc3, 0x0e,
0x2e, 0x61, 0x8a, 0x07, 0xf1, 0x54, 0x6f, 0xc3, 0xdb, 0xf0, 0xa2, 0x1e, 0x4a, 0x9a, 0xbc, 0xd6,
0x97, 0x36, 0x4d, 0x69, 0xd2, 0x6a, 0x3e, 0x9c, 0xdf, 0x4d, 0x4c, 0x36, 0x90, 0x9d, 0xbc, 0xbe,
0xcf, 0xfb, 0x7b, 0x9e, 0x87, 0x87, 0xdc, 0x7a, 0xd1, 0x2a, 0xf8, 0xe4, 0xb2, 0x31, 0x83, 0xe2,
0x28, 0x34, 0x1f, 0x37, 0x5c, 0x7c, 0x58, 0x69, 0x74, 0x27, 0x1c, 0x96, 0xd8, 0xa0, 0xf3, 0x5c,
0x48, 0x09, 0xd6, 0x16, 0x35, 0x78, 0xd6, 0xf5, 0xc6, 0x19, 0x7a, 0x19, 0x31, 0x16, 0x30, 0x86,
0x42, 0xb3, 0x71, 0xc3, 0x8e, 0xb1, 0xe5, 0x79, 0x65, 0x4c, 0xd5, 0x00, 0x0f, 0x4c, 0x39, 0xbc,
0x71, 0x87, 0x1a, 0xac, 0x13, 0xba, 0x8b, 0x36, 0x17, 0x5f, 0x09, 0x99, 0xe7, 0xc1, 0xfb, 0x11,
0x3c, 0x3d, 0x21, 0x13, 0x54, 0x69, 0x92, 0x25, 0xab, 0xf9, 0x6e, 0x82, 0x8a, 0x5e, 0x11, 0x6a,
0xa1, 0x1f, 0x51, 0x42, 0x21, 0xa4, 0x34, 0x43, 0xeb, 0x0a, 0x54, 0xe9, 0x24, 0xe8, 0xa7, 0x7b,
0x25, 0x8f, 0xc2, 0x56, 0xd1, 0x3b, 0x42, 0x64, 0x0f, 0xc2, 0x81, 0x2a, 0x84, 0x4b, 0xff, 0x65,
0xc9, 0x6a, 0x71, 0xbd, 0x64, 0xb1, 0x01, 0x3b, 0x34, 0x60, 0x4f, 0x87, 0x06, 0xbb, 0xf9, 0xfe,
0x3b, 0x77, 0x34, 0x23, 0x0b, 0x05, 0x56, 0xf6, 0xd8, 0x39, 0x34, 0x6d, 0xfa, 0x3f, 0x24, 0xfc,
0x3e, 0xd1, 0x33, 0x32, 0xab, 0xc1, 0xff, 0xc4, 0x4f, 0x83, 0x38, 0xad, 0xc1, 0x6f, 0xd5, 0xc3,
0xeb, 0xcb, 0x73, 0x85, 0xee, 0x7d, 0x28, 0x99, 0x34, 0x9a, 0xc7, 0x4d, 0xd6, 0x71, 0xca, 0xca,
0xac, 0x2b, 0x68, 0x43, 0x2e, 0xff, 0xcb, 0xc6, 0xf7, 0xc7, 0x87, 0x72, 0x16, 0xe0, 0x9b, 0xef,
0x00, 0x00, 0x00, 0xff, 0xff, 0x6e, 0x37, 0x35, 0xf6, 0xa3, 0x01, 0x00, 0x00,
}

565
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility/access_key_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,565 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/awscompatibility/access_key_service.proto
package awscompatibility // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetAccessKeyRequest struct {
// ID of the AccessKey resource to return.
// To get the access key ID, use a [AccessKeyService.List] request.
AccessKeyId string `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetAccessKeyRequest) Reset() { *m = GetAccessKeyRequest{} }
func (m *GetAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*GetAccessKeyRequest) ProtoMessage() {}
func (*GetAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{0}
}
func (m *GetAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAccessKeyRequest.Unmarshal(m, b)
}
func (m *GetAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *GetAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetAccessKeyRequest.Merge(dst, src)
}
func (m *GetAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_GetAccessKeyRequest.Size(m)
}
func (m *GetAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetAccessKeyRequest proto.InternalMessageInfo
func (m *GetAccessKeyRequest) GetAccessKeyId() string {
if m != nil {
return m.AccessKeyId
}
return ""
}
type ListAccessKeysRequest struct {
// ID of the service account to list access keys for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListAccessKeysResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token]
// to the [ListAccessKeysResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessKeysRequest) Reset() { *m = ListAccessKeysRequest{} }
func (m *ListAccessKeysRequest) String() string { return proto.CompactTextString(m) }
func (*ListAccessKeysRequest) ProtoMessage() {}
func (*ListAccessKeysRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{1}
}
func (m *ListAccessKeysRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessKeysRequest.Unmarshal(m, b)
}
func (m *ListAccessKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessKeysRequest.Marshal(b, m, deterministic)
}
func (dst *ListAccessKeysRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessKeysRequest.Merge(dst, src)
}
func (m *ListAccessKeysRequest) XXX_Size() int {
return xxx_messageInfo_ListAccessKeysRequest.Size(m)
}
func (m *ListAccessKeysRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessKeysRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessKeysRequest proto.InternalMessageInfo
func (m *ListAccessKeysRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ListAccessKeysRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListAccessKeysRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListAccessKeysResponse struct {
// List of access keys.
AccessKeys []*AccessKey `protobuf:"bytes,1,rep,name=access_keys,json=accessKeys,proto3" json:"access_keys,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListAccessKeysRequest.page_size], use
// the [next_page_token] as the value
// for the [ListAccessKeysRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessKeysResponse) Reset() { *m = ListAccessKeysResponse{} }
func (m *ListAccessKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListAccessKeysResponse) ProtoMessage() {}
func (*ListAccessKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{2}
}
func (m *ListAccessKeysResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessKeysResponse.Unmarshal(m, b)
}
func (m *ListAccessKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessKeysResponse.Marshal(b, m, deterministic)
}
func (dst *ListAccessKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessKeysResponse.Merge(dst, src)
}
func (m *ListAccessKeysResponse) XXX_Size() int {
return xxx_messageInfo_ListAccessKeysResponse.Size(m)
}
func (m *ListAccessKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessKeysResponse proto.InternalMessageInfo
func (m *ListAccessKeysResponse) GetAccessKeys() []*AccessKey {
if m != nil {
return m.AccessKeys
}
return nil
}
func (m *ListAccessKeysResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateAccessKeyRequest struct {
// ID of the service account to create an access key for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Description of the access key.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateAccessKeyRequest) Reset() { *m = CreateAccessKeyRequest{} }
func (m *CreateAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateAccessKeyRequest) ProtoMessage() {}
func (*CreateAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{3}
}
func (m *CreateAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateAccessKeyRequest.Unmarshal(m, b)
}
func (m *CreateAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *CreateAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateAccessKeyRequest.Merge(dst, src)
}
func (m *CreateAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_CreateAccessKeyRequest.Size(m)
}
func (m *CreateAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateAccessKeyRequest proto.InternalMessageInfo
func (m *CreateAccessKeyRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *CreateAccessKeyRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
type CreateAccessKeyResponse struct {
// AccessKey resource.
AccessKey *AccessKey `protobuf:"bytes,1,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"`
// Secret access key.
// The key is AWS compatible.
Secret string `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateAccessKeyResponse) Reset() { *m = CreateAccessKeyResponse{} }
func (m *CreateAccessKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateAccessKeyResponse) ProtoMessage() {}
func (*CreateAccessKeyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{4}
}
func (m *CreateAccessKeyResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateAccessKeyResponse.Unmarshal(m, b)
}
func (m *CreateAccessKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateAccessKeyResponse.Marshal(b, m, deterministic)
}
func (dst *CreateAccessKeyResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateAccessKeyResponse.Merge(dst, src)
}
func (m *CreateAccessKeyResponse) XXX_Size() int {
return xxx_messageInfo_CreateAccessKeyResponse.Size(m)
}
func (m *CreateAccessKeyResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateAccessKeyResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateAccessKeyResponse proto.InternalMessageInfo
func (m *CreateAccessKeyResponse) GetAccessKey() *AccessKey {
if m != nil {
return m.AccessKey
}
return nil
}
func (m *CreateAccessKeyResponse) GetSecret() string {
if m != nil {
return m.Secret
}
return ""
}
type DeleteAccessKeyRequest struct {
// ID of the access key to delete.
// To get the access key ID, use a [AccessKeyService.List] request.
AccessKeyId string `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteAccessKeyRequest) Reset() { *m = DeleteAccessKeyRequest{} }
func (m *DeleteAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteAccessKeyRequest) ProtoMessage() {}
func (*DeleteAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_1bf1b5014c53758f, []int{5}
}
func (m *DeleteAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteAccessKeyRequest.Unmarshal(m, b)
}
func (m *DeleteAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteAccessKeyRequest.Merge(dst, src)
}
func (m *DeleteAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_DeleteAccessKeyRequest.Size(m)
}
func (m *DeleteAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteAccessKeyRequest proto.InternalMessageInfo
func (m *DeleteAccessKeyRequest) GetAccessKeyId() string {
if m != nil {
return m.AccessKeyId
}
return ""
}
func init() {
proto.RegisterType((*GetAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.GetAccessKeyRequest")
proto.RegisterType((*ListAccessKeysRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.ListAccessKeysRequest")
proto.RegisterType((*ListAccessKeysResponse)(nil), "yandex.cloud.iam.v1.awscompatibility.ListAccessKeysResponse")
proto.RegisterType((*CreateAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.CreateAccessKeyRequest")
proto.RegisterType((*CreateAccessKeyResponse)(nil), "yandex.cloud.iam.v1.awscompatibility.CreateAccessKeyResponse")
proto.RegisterType((*DeleteAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.DeleteAccessKeyRequest")
}
// 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
// AccessKeyServiceClient is the client API for AccessKeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AccessKeyServiceClient interface {
// Retrieves the list of access keys for the specified service account.
List(ctx context.Context, in *ListAccessKeysRequest, opts ...grpc.CallOption) (*ListAccessKeysResponse, error)
// Returns the specified access key.
//
// To get the list of available access keys, make a [List] request.
Get(ctx context.Context, in *GetAccessKeyRequest, opts ...grpc.CallOption) (*AccessKey, error)
// Creates an access key for the specified service account.
Create(ctx context.Context, in *CreateAccessKeyRequest, opts ...grpc.CallOption) (*CreateAccessKeyResponse, error)
// Deletes the specified access key.
Delete(ctx context.Context, in *DeleteAccessKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type accessKeyServiceClient struct {
cc *grpc.ClientConn
}
func NewAccessKeyServiceClient(cc *grpc.ClientConn) AccessKeyServiceClient {
return &accessKeyServiceClient{cc}
}
func (c *accessKeyServiceClient) List(ctx context.Context, in *ListAccessKeysRequest, opts ...grpc.CallOption) (*ListAccessKeysResponse, error) {
out := new(ListAccessKeysResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Get(ctx context.Context, in *GetAccessKeyRequest, opts ...grpc.CallOption) (*AccessKey, error) {
out := new(AccessKey)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Create(ctx context.Context, in *CreateAccessKeyRequest, opts ...grpc.CallOption) (*CreateAccessKeyResponse, error) {
out := new(CreateAccessKeyResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Delete(ctx context.Context, in *DeleteAccessKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AccessKeyServiceServer is the server API for AccessKeyService service.
type AccessKeyServiceServer interface {
// Retrieves the list of access keys for the specified service account.
List(context.Context, *ListAccessKeysRequest) (*ListAccessKeysResponse, error)
// Returns the specified access key.
//
// To get the list of available access keys, make a [List] request.
Get(context.Context, *GetAccessKeyRequest) (*AccessKey, error)
// Creates an access key for the specified service account.
Create(context.Context, *CreateAccessKeyRequest) (*CreateAccessKeyResponse, error)
// Deletes the specified access key.
Delete(context.Context, *DeleteAccessKeyRequest) (*empty.Empty, error)
}
func RegisterAccessKeyServiceServer(s *grpc.Server, srv AccessKeyServiceServer) {
s.RegisterService(&_AccessKeyService_serviceDesc, srv)
}
func _AccessKeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListAccessKeysRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).List(ctx, req.(*ListAccessKeysRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Get(ctx, req.(*GetAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Create(ctx, req.(*CreateAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Delete(ctx, req.(*DeleteAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
var _AccessKeyService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.awscompatibility.AccessKeyService",
HandlerType: (*AccessKeyServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "List",
Handler: _AccessKeyService_List_Handler,
},
{
MethodName: "Get",
Handler: _AccessKeyService_Get_Handler,
},
{
MethodName: "Create",
Handler: _AccessKeyService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _AccessKeyService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/awscompatibility/access_key_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/awscompatibility/access_key_service.proto", fileDescriptor_access_key_service_1bf1b5014c53758f)
}
var fileDescriptor_access_key_service_1bf1b5014c53758f = []byte{
// 649 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0xbf, 0x6e, 0x13, 0x4b,
0x14, 0xc6, 0x35, 0x71, 0x62, 0xc5, 0xc7, 0x37, 0xba, 0xd1, 0x5c, 0x5d, 0x63, 0x19, 0x90, 0xa2,
0x55, 0x14, 0x4c, 0x20, 0x3b, 0xde, 0x40, 0x22, 0x41, 0xec, 0x22, 0x01, 0x14, 0x05, 0x10, 0x8a,
0x1c, 0x1a, 0xa0, 0xb0, 0xc6, 0xbb, 0x07, 0x33, 0x8a, 0xbd, 0xb3, 0x78, 0xc6, 0x4e, 0x1c, 0x94,
0x02, 0xca, 0x94, 0xd0, 0x52, 0xf1, 0x02, 0xe9, 0x78, 0x85, 0xa4, 0xa2, 0xe1, 0x15, 0x28, 0x78,
0x06, 0x2a, 0xb4, 0xb3, 0x6b, 0x3b, 0x7f, 0x5c, 0x6c, 0x5c, 0xee, 0x9c, 0xf9, 0xce, 0xf9, 0xe6,
0x77, 0xce, 0xcc, 0x42, 0xa5, 0xc7, 0x7d, 0x0f, 0xf7, 0x99, 0xdb, 0x94, 0x1d, 0x8f, 0x09, 0xde,
0x62, 0x5d, 0x87, 0xf1, 0x3d, 0xe5, 0xca, 0x56, 0xc0, 0xb5, 0xa8, 0x8b, 0xa6, 0xd0, 0x3d, 0xc6,
0x5d, 0x17, 0x95, 0xaa, 0xed, 0x62, 0xaf, 0xa6, 0xb0, 0xdd, 0x15, 0x2e, 0xda, 0x41, 0x5b, 0x6a,
0x49, 0xe7, 0x23, 0xb9, 0x6d, 0xe4, 0xb6, 0xe0, 0x2d, 0xbb, 0xeb, 0xd8, 0x17, 0xe5, 0x85, 0x1b,
0x0d, 0x29, 0x1b, 0x4d, 0x64, 0x3c, 0x10, 0x8c, 0xfb, 0xbe, 0xd4, 0x5c, 0x0b, 0xe9, 0xab, 0x28,
0x47, 0xe1, 0x7a, 0x1c, 0x35, 0x5f, 0xf5, 0xce, 0x5b, 0x86, 0xad, 0x40, 0xf7, 0xe2, 0xe0, 0xca,
0x15, 0xfd, 0xc5, 0xb2, 0x9b, 0xe7, 0x64, 0x5d, 0xde, 0x14, 0x9e, 0xa9, 0x19, 0x85, 0xad, 0x4d,
0xf8, 0x6f, 0x13, 0xf5, 0xba, 0x51, 0x3d, 0xc3, 0x5e, 0x15, 0xdf, 0x77, 0x50, 0x69, 0x5a, 0x82,
0x99, 0x33, 0x27, 0x15, 0x5e, 0x9e, 0xcc, 0x91, 0x62, 0x66, 0xe3, 0x9f, 0xdf, 0x27, 0x0e, 0x39,
0x3a, 0x75, 0x26, 0xcb, 0x95, 0x95, 0x52, 0x35, 0xcb, 0xfb, 0xb2, 0x2d, 0xcf, 0xfa, 0x46, 0xe0,
0xff, 0xe7, 0x42, 0x0d, 0x53, 0xa9, 0x7e, 0xae, 0x55, 0xa0, 0x31, 0xaa, 0x1a, 0x77, 0x5d, 0xd9,
0xf1, 0xf5, 0x30, 0xe1, 0xf4, 0x20, 0xd9, 0x6c, 0xbc, 0x67, 0x3d, 0xda, 0xb2, 0xe5, 0xd1, 0x5b,
0x90, 0x09, 0x78, 0x03, 0x6b, 0x4a, 0x1c, 0x60, 0x7e, 0x62, 0x8e, 0x14, 0x53, 0x1b, 0xf0, 0xe7,
0xc4, 0x49, 0x97, 0x2b, 0x4e, 0xa9, 0x54, 0xaa, 0x4e, 0x87, 0xc1, 0x1d, 0x71, 0x80, 0xb4, 0x08,
0x60, 0x36, 0x6a, 0xb9, 0x8b, 0x7e, 0x3e, 0x65, 0x12, 0x67, 0x8e, 0x4e, 0x9d, 0x29, 0xb3, 0xb3,
0x6a, 0xb2, 0xbc, 0x0c, 0x63, 0xd6, 0x67, 0x02, 0xb9, 0x8b, 0x26, 0x55, 0x20, 0x7d, 0x85, 0x74,
0x1b, 0xb2, 0xc3, 0x13, 0xab, 0x3c, 0x99, 0x4b, 0x15, 0xb3, 0xcb, 0xcc, 0x4e, 0xd2, 0x55, 0x7b,
0x88, 0x0f, 0x06, 0x48, 0x14, 0x5d, 0x80, 0x7f, 0x7d, 0xdc, 0xd7, 0xb5, 0x33, 0xde, 0xc2, 0x53,
0x64, 0xaa, 0x33, 0xe1, 0xf2, 0xf6, 0xc0, 0xd4, 0x21, 0xe4, 0x1e, 0xb5, 0x91, 0x6b, 0xbc, 0xd4,
0x85, 0x71, 0xc9, 0xdd, 0x81, 0xac, 0x87, 0xca, 0x6d, 0x8b, 0x20, 0xec, 0x74, 0x54, 0xb5, 0x4f,
0x64, 0x79, 0x65, 0xb5, 0x7a, 0x36, 0x6a, 0x7d, 0x24, 0x70, 0xed, 0x52, 0xfd, 0x18, 0xca, 0x0b,
0x80, 0x21, 0x14, 0x53, 0x78, 0x0c, 0x26, 0x99, 0x01, 0x13, 0x9a, 0x83, 0xb4, 0x42, 0xb7, 0x8d,
0x3a, 0x26, 0x11, 0x7f, 0x59, 0x4f, 0x21, 0xf7, 0x18, 0x9b, 0x38, 0x02, 0xc1, 0x95, 0x07, 0x71,
0xf9, 0xc7, 0x14, 0xcc, 0x0e, 0xd2, 0xec, 0x44, 0x68, 0xe8, 0x31, 0x81, 0xc9, 0xb0, 0xf1, 0x74,
0x2d, 0x99, 0xfb, 0x91, 0x93, 0x5c, 0x28, 0x8f, 0x27, 0x8e, 0x60, 0x5a, 0x77, 0x3f, 0xfd, 0xfc,
0xf5, 0x65, 0x62, 0x81, 0xce, 0x9b, 0xcb, 0xcb, 0xf7, 0xd4, 0xd2, 0xf9, 0xab, 0x1b, 0x5e, 0xe7,
0xe1, 0xf4, 0x1c, 0x13, 0x48, 0x6d, 0xa2, 0xa6, 0x0f, 0x92, 0xd5, 0x1c, 0x71, 0x89, 0x0b, 0x57,
0xed, 0x94, 0x55, 0x36, 0x0e, 0x57, 0xe9, 0xfd, 0x24, 0x0e, 0xd9, 0x87, 0x73, 0x8d, 0x39, 0xa4,
0xdf, 0x09, 0xa4, 0xa3, 0x41, 0xa2, 0x09, 0x41, 0x8d, 0x1e, 0xfb, 0x42, 0x65, 0x4c, 0x75, 0xcc,
0x99, 0x99, 0x53, 0xdc, 0xb6, 0x12, 0x71, 0x7e, 0x48, 0x16, 0xe9, 0x57, 0x02, 0xe9, 0x68, 0xfc,
0x92, 0x1a, 0x1f, 0x3d, 0xac, 0x85, 0x9c, 0x1d, 0x3d, 0xe0, 0x76, 0xff, 0x01, 0xb7, 0x9f, 0x84,
0x0f, 0x78, 0x9f, 0xeb, 0xe2, 0x58, 0x5c, 0x37, 0xde, 0xbc, 0x7e, 0xd5, 0x10, 0xfa, 0x5d, 0xa7,
0x6e, 0xbb, 0xb2, 0xc5, 0x22, 0x7f, 0x4b, 0xd1, 0x73, 0xde, 0x90, 0x4b, 0x0d, 0xf4, 0x4d, 0x35,
0x96, 0xe4, 0xf7, 0xb0, 0x76, 0x71, 0xa1, 0x9e, 0x36, 0xe2, 0x7b, 0x7f, 0x03, 0x00, 0x00, 0xff,
0xff, 0xaa, 0xd6, 0x8e, 0x16, 0xfe, 0x06, 0x00, 0x00,
}

326
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/iam_token_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,326 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/iam_token_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type CreateIamTokenRequest struct {
// Types that are valid to be assigned to Identity:
// *CreateIamTokenRequest_YandexPassportOauthToken
// *CreateIamTokenRequest_Jwt
Identity isCreateIamTokenRequest_Identity `protobuf_oneof:"identity"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateIamTokenRequest) Reset() { *m = CreateIamTokenRequest{} }
func (m *CreateIamTokenRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIamTokenRequest) ProtoMessage() {}
func (*CreateIamTokenRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_iam_token_service_021a8da7029cec45, []int{0}
}
func (m *CreateIamTokenRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateIamTokenRequest.Unmarshal(m, b)
}
func (m *CreateIamTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateIamTokenRequest.Marshal(b, m, deterministic)
}
func (dst *CreateIamTokenRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateIamTokenRequest.Merge(dst, src)
}
func (m *CreateIamTokenRequest) XXX_Size() int {
return xxx_messageInfo_CreateIamTokenRequest.Size(m)
}
func (m *CreateIamTokenRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateIamTokenRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateIamTokenRequest proto.InternalMessageInfo
type isCreateIamTokenRequest_Identity interface {
isCreateIamTokenRequest_Identity()
}
type CreateIamTokenRequest_YandexPassportOauthToken struct {
YandexPassportOauthToken string `protobuf:"bytes,1,opt,name=yandex_passport_oauth_token,json=yandexPassportOauthToken,proto3,oneof"`
}
type CreateIamTokenRequest_Jwt struct {
Jwt string `protobuf:"bytes,2,opt,name=jwt,proto3,oneof"`
}
func (*CreateIamTokenRequest_YandexPassportOauthToken) isCreateIamTokenRequest_Identity() {}
func (*CreateIamTokenRequest_Jwt) isCreateIamTokenRequest_Identity() {}
func (m *CreateIamTokenRequest) GetIdentity() isCreateIamTokenRequest_Identity {
if m != nil {
return m.Identity
}
return nil
}
func (m *CreateIamTokenRequest) GetYandexPassportOauthToken() string {
if x, ok := m.GetIdentity().(*CreateIamTokenRequest_YandexPassportOauthToken); ok {
return x.YandexPassportOauthToken
}
return ""
}
func (m *CreateIamTokenRequest) GetJwt() string {
if x, ok := m.GetIdentity().(*CreateIamTokenRequest_Jwt); ok {
return x.Jwt
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*CreateIamTokenRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _CreateIamTokenRequest_OneofMarshaler, _CreateIamTokenRequest_OneofUnmarshaler, _CreateIamTokenRequest_OneofSizer, []interface{}{
(*CreateIamTokenRequest_YandexPassportOauthToken)(nil),
(*CreateIamTokenRequest_Jwt)(nil),
}
}
func _CreateIamTokenRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*CreateIamTokenRequest)
// identity
switch x := m.Identity.(type) {
case *CreateIamTokenRequest_YandexPassportOauthToken:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.YandexPassportOauthToken)
case *CreateIamTokenRequest_Jwt:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Jwt)
case nil:
default:
return fmt.Errorf("CreateIamTokenRequest.Identity has unexpected type %T", x)
}
return nil
}
func _CreateIamTokenRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*CreateIamTokenRequest)
switch tag {
case 1: // identity.yandex_passport_oauth_token
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Identity = &CreateIamTokenRequest_YandexPassportOauthToken{x}
return true, err
case 2: // identity.jwt
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Identity = &CreateIamTokenRequest_Jwt{x}
return true, err
default:
return false, nil
}
}
func _CreateIamTokenRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*CreateIamTokenRequest)
// identity
switch x := m.Identity.(type) {
case *CreateIamTokenRequest_YandexPassportOauthToken:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.YandexPassportOauthToken)))
n += len(x.YandexPassportOauthToken)
case *CreateIamTokenRequest_Jwt:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.Jwt)))
n += len(x.Jwt)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type CreateIamTokenResponse struct {
// IAM token for the specified identity.
//
// You should pass the token in the `Authorization` header for any further API requests.
// For example, `Authorization: Bearer [iam_token]`.
IamToken string `protobuf:"bytes,1,opt,name=iam_token,json=iamToken,proto3" json:"iam_token,omitempty"`
// IAM token expiration time, in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
ExpiresAt *timestamp.Timestamp `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateIamTokenResponse) Reset() { *m = CreateIamTokenResponse{} }
func (m *CreateIamTokenResponse) String() string { return proto.CompactTextString(m) }
func (*CreateIamTokenResponse) ProtoMessage() {}
func (*CreateIamTokenResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_iam_token_service_021a8da7029cec45, []int{1}
}
func (m *CreateIamTokenResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateIamTokenResponse.Unmarshal(m, b)
}
func (m *CreateIamTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateIamTokenResponse.Marshal(b, m, deterministic)
}
func (dst *CreateIamTokenResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateIamTokenResponse.Merge(dst, src)
}
func (m *CreateIamTokenResponse) XXX_Size() int {
return xxx_messageInfo_CreateIamTokenResponse.Size(m)
}
func (m *CreateIamTokenResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateIamTokenResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateIamTokenResponse proto.InternalMessageInfo
func (m *CreateIamTokenResponse) GetIamToken() string {
if m != nil {
return m.IamToken
}
return ""
}
func (m *CreateIamTokenResponse) GetExpiresAt() *timestamp.Timestamp {
if m != nil {
return m.ExpiresAt
}
return nil
}
func init() {
proto.RegisterType((*CreateIamTokenRequest)(nil), "yandex.cloud.iam.v1.CreateIamTokenRequest")
proto.RegisterType((*CreateIamTokenResponse)(nil), "yandex.cloud.iam.v1.CreateIamTokenResponse")
}
// 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
// IamTokenServiceClient is the client API for IamTokenService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IamTokenServiceClient interface {
// Creates an IAM token for the specified identity.
Create(ctx context.Context, in *CreateIamTokenRequest, opts ...grpc.CallOption) (*CreateIamTokenResponse, error)
}
type iamTokenServiceClient struct {
cc *grpc.ClientConn
}
func NewIamTokenServiceClient(cc *grpc.ClientConn) IamTokenServiceClient {
return &iamTokenServiceClient{cc}
}
func (c *iamTokenServiceClient) Create(ctx context.Context, in *CreateIamTokenRequest, opts ...grpc.CallOption) (*CreateIamTokenResponse, error) {
out := new(CreateIamTokenResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.IamTokenService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// IamTokenServiceServer is the server API for IamTokenService service.
type IamTokenServiceServer interface {
// Creates an IAM token for the specified identity.
Create(context.Context, *CreateIamTokenRequest) (*CreateIamTokenResponse, error)
}
func RegisterIamTokenServiceServer(s *grpc.Server, srv IamTokenServiceServer) {
s.RegisterService(&_IamTokenService_serviceDesc, srv)
}
func _IamTokenService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateIamTokenRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IamTokenServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.IamTokenService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IamTokenServiceServer).Create(ctx, req.(*CreateIamTokenRequest))
}
return interceptor(ctx, in, info, handler)
}
var _IamTokenService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.IamTokenService",
HandlerType: (*IamTokenServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Create",
Handler: _IamTokenService_Create_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/iam_token_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/iam_token_service.proto", fileDescriptor_iam_token_service_021a8da7029cec45)
}
var fileDescriptor_iam_token_service_021a8da7029cec45 = []byte{
// 382 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x4e, 0xdb, 0x30,
0x18, 0xc7, 0x97, 0x6e, 0xaa, 0x5a, 0x4f, 0xda, 0x26, 0x57, 0x9b, 0xba, 0x74, 0xd3, 0xa6, 0x9c,
0x50, 0xab, 0xda, 0x6a, 0x39, 0x41, 0x85, 0x10, 0xe5, 0x02, 0x27, 0x50, 0xe8, 0x89, 0x4b, 0xe4,
0x36, 0x26, 0x35, 0x34, 0xb6, 0x89, 0xbf, 0x84, 0x56, 0x42, 0x1c, 0x78, 0x01, 0x0e, 0xbc, 0x10,
0x3c, 0x03, 0xaf, 0xc0, 0x83, 0xa0, 0xc4, 0x09, 0x12, 0xa8, 0x07, 0x4e, 0x96, 0xf5, 0xfd, 0xfc,
0xfd, 0xff, 0xdf, 0xdf, 0x1f, 0xea, 0xad, 0x98, 0x0c, 0xf9, 0x92, 0xce, 0x16, 0x2a, 0x0d, 0xa9,
0x60, 0x31, 0xcd, 0x06, 0xf9, 0x11, 0x80, 0xba, 0xe0, 0x32, 0x30, 0x3c, 0xc9, 0xc4, 0x8c, 0x13,
0x9d, 0x28, 0x50, 0xb8, 0x65, 0x61, 0x52, 0xc0, 0x44, 0xb0, 0x98, 0x64, 0x03, 0xf7, 0x4f, 0xa4,
0x54, 0xb4, 0xe0, 0x94, 0x69, 0x41, 0x99, 0x94, 0x0a, 0x18, 0x08, 0x25, 0x8d, 0x7d, 0xe2, 0xfe,
0x2b, 0xab, 0xc5, 0x6d, 0x9a, 0x9e, 0x51, 0x10, 0x31, 0x37, 0xc0, 0x62, 0x5d, 0x02, 0x7f, 0xdf,
0x18, 0xc8, 0xd8, 0x42, 0x84, 0x45, 0x03, 0x5b, 0xf6, 0x6e, 0xd0, 0xcf, 0xfd, 0x84, 0x33, 0xe0,
0x87, 0x2c, 0x9e, 0xe4, 0x96, 0x7c, 0x7e, 0x99, 0x72, 0x03, 0x78, 0x17, 0x75, 0xec, 0xcb, 0x40,
0x33, 0x63, 0xb4, 0x4a, 0x20, 0x50, 0x2c, 0x85, 0xb9, 0x35, 0xde, 0x76, 0xfe, 0x3b, 0x1b, 0xcd,
0x83, 0x4f, 0x7e, 0xdb, 0x42, 0xc7, 0x25, 0x73, 0x94, 0x23, 0x45, 0x1f, 0x8c, 0xd1, 0xe7, 0xf3,
0x2b, 0x68, 0xd7, 0x4a, 0x30, 0xbf, 0x8c, 0x7f, 0xa0, 0x86, 0x08, 0xb9, 0x04, 0x01, 0x2b, 0xfc,
0xe5, 0xe1, 0x71, 0xe0, 0x78, 0x1a, 0xfd, 0x7a, 0xaf, 0x6f, 0xb4, 0x92, 0x86, 0xe3, 0x0e, 0x6a,
0xbe, 0xe6, 0x64, 0xe5, 0xfc, 0x86, 0x28, 0x21, 0xbc, 0x85, 0x10, 0x5f, 0x6a, 0x91, 0x70, 0x13,
0x30, 0xab, 0xf1, 0x75, 0xe8, 0x12, 0x9b, 0x05, 0xa9, 0xb2, 0x20, 0x93, 0x2a, 0x0b, 0xbf, 0x59,
0xd2, 0x7b, 0x30, 0xbc, 0x73, 0xd0, 0xf7, 0x4a, 0xec, 0xc4, 0xc6, 0x8f, 0xaf, 0x51, 0xdd, 0xba,
0xc0, 0x5d, 0xb2, 0xe6, 0x0f, 0xc8, 0xda, 0x88, 0xdc, 0xde, 0x87, 0x58, 0x3b, 0x8e, 0xf7, 0xfb,
0xf6, 0xe9, 0xf9, 0xbe, 0xd6, 0xf2, 0xbe, 0x55, 0x4b, 0x50, 0x0c, 0x66, 0xb6, 0x9d, 0xee, 0x78,
0xe7, 0x74, 0x14, 0x09, 0x98, 0xa7, 0x53, 0x32, 0x53, 0x31, 0xb5, 0x3d, 0xfb, 0xf6, 0xbf, 0x22,
0xd5, 0x8f, 0xb8, 0x2c, 0x06, 0xa2, 0x6b, 0x36, 0x69, 0x24, 0x58, 0x3c, 0xad, 0x17, 0xe5, 0xcd,
0x97, 0x00, 0x00, 0x00, 0xff, 0xff, 0xda, 0xac, 0x14, 0x7c, 0x6b, 0x02, 0x00, 0x00,
}

266
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/key.pb.go generated vendored Normal file
View File

@ -0,0 +1,266 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/key.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type Key_Algorithm int32
const (
Key_ALGORITHM_UNSPECIFIED Key_Algorithm = 0
// RSA with a 2048-bit key size. Default value.
Key_RSA_2048 Key_Algorithm = 1
// RSA with a 4096-bit key size.
Key_RSA_4096 Key_Algorithm = 2
)
var Key_Algorithm_name = map[int32]string{
0: "ALGORITHM_UNSPECIFIED",
1: "RSA_2048",
2: "RSA_4096",
}
var Key_Algorithm_value = map[string]int32{
"ALGORITHM_UNSPECIFIED": 0,
"RSA_2048": 1,
"RSA_4096": 2,
}
func (x Key_Algorithm) String() string {
return proto.EnumName(Key_Algorithm_name, int32(x))
}
func (Key_Algorithm) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_key_8778cd8d03fc7198, []int{0, 0}
}
// A Key resource. For more information, see [Authorized keys](/docs/iam/concepts/authorization/key).
type Key struct {
// ID of the Key resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Types that are valid to be assigned to Subject:
// *Key_UserAccountId
// *Key_ServiceAccountId
Subject isKey_Subject `protobuf_oneof:"subject"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Description of the Key resource. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// An algorithm used to generate a key pair of the Key resource.
KeyAlgorithm Key_Algorithm `protobuf:"varint,6,opt,name=key_algorithm,json=keyAlgorithm,proto3,enum=yandex.cloud.iam.v1.Key_Algorithm" json:"key_algorithm,omitempty"`
// A public key of the Key resource.
PublicKey string `protobuf:"bytes,7,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Key) Reset() { *m = Key{} }
func (m *Key) String() string { return proto.CompactTextString(m) }
func (*Key) ProtoMessage() {}
func (*Key) Descriptor() ([]byte, []int) {
return fileDescriptor_key_8778cd8d03fc7198, []int{0}
}
func (m *Key) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Key.Unmarshal(m, b)
}
func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Key.Marshal(b, m, deterministic)
}
func (dst *Key) XXX_Merge(src proto.Message) {
xxx_messageInfo_Key.Merge(dst, src)
}
func (m *Key) XXX_Size() int {
return xxx_messageInfo_Key.Size(m)
}
func (m *Key) XXX_DiscardUnknown() {
xxx_messageInfo_Key.DiscardUnknown(m)
}
var xxx_messageInfo_Key proto.InternalMessageInfo
func (m *Key) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type isKey_Subject interface {
isKey_Subject()
}
type Key_UserAccountId struct {
UserAccountId string `protobuf:"bytes,2,opt,name=user_account_id,json=userAccountId,proto3,oneof"`
}
type Key_ServiceAccountId struct {
ServiceAccountId string `protobuf:"bytes,3,opt,name=service_account_id,json=serviceAccountId,proto3,oneof"`
}
func (*Key_UserAccountId) isKey_Subject() {}
func (*Key_ServiceAccountId) isKey_Subject() {}
func (m *Key) GetSubject() isKey_Subject {
if m != nil {
return m.Subject
}
return nil
}
func (m *Key) GetUserAccountId() string {
if x, ok := m.GetSubject().(*Key_UserAccountId); ok {
return x.UserAccountId
}
return ""
}
func (m *Key) GetServiceAccountId() string {
if x, ok := m.GetSubject().(*Key_ServiceAccountId); ok {
return x.ServiceAccountId
}
return ""
}
func (m *Key) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Key) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Key) GetKeyAlgorithm() Key_Algorithm {
if m != nil {
return m.KeyAlgorithm
}
return Key_ALGORITHM_UNSPECIFIED
}
func (m *Key) GetPublicKey() string {
if m != nil {
return m.PublicKey
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Key) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Key_OneofMarshaler, _Key_OneofUnmarshaler, _Key_OneofSizer, []interface{}{
(*Key_UserAccountId)(nil),
(*Key_ServiceAccountId)(nil),
}
}
func _Key_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Key)
// subject
switch x := m.Subject.(type) {
case *Key_UserAccountId:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.UserAccountId)
case *Key_ServiceAccountId:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.ServiceAccountId)
case nil:
default:
return fmt.Errorf("Key.Subject has unexpected type %T", x)
}
return nil
}
func _Key_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Key)
switch tag {
case 2: // subject.user_account_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Subject = &Key_UserAccountId{x}
return true, err
case 3: // subject.service_account_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Subject = &Key_ServiceAccountId{x}
return true, err
default:
return false, nil
}
}
func _Key_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Key)
// subject
switch x := m.Subject.(type) {
case *Key_UserAccountId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.UserAccountId)))
n += len(x.UserAccountId)
case *Key_ServiceAccountId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.ServiceAccountId)))
n += len(x.ServiceAccountId)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*Key)(nil), "yandex.cloud.iam.v1.Key")
proto.RegisterEnum("yandex.cloud.iam.v1.Key_Algorithm", Key_Algorithm_name, Key_Algorithm_value)
}
func init() { proto.RegisterFile("yandex/cloud/iam/v1/key.proto", fileDescriptor_key_8778cd8d03fc7198) }
var fileDescriptor_key_8778cd8d03fc7198 = []byte{
// 384 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4b, 0x6f, 0xd4, 0x30,
0x14, 0x85, 0x9b, 0x0c, 0xb4, 0xc4, 0x7d, 0x10, 0x19, 0x21, 0x85, 0x4a, 0x15, 0xd1, 0xac, 0xb2,
0xa9, 0xdd, 0x0e, 0x15, 0xa2, 0xaa, 0x58, 0x64, 0xa0, 0xb4, 0xd1, 0xf0, 0x52, 0x5a, 0x36, 0x6c,
0x22, 0xc7, 0xbe, 0xa4, 0x26, 0x0f, 0x47, 0x89, 0x33, 0xc2, 0x6b, 0xfe, 0x38, 0x6a, 0x32, 0x61,
0x66, 0x31, 0xcb, 0x7b, 0xbe, 0xcf, 0xf2, 0xd1, 0xb5, 0xd1, 0x89, 0x61, 0x95, 0x80, 0x3f, 0x94,
0x17, 0xaa, 0x13, 0x54, 0xb2, 0x92, 0x2e, 0xcf, 0x69, 0x0e, 0x86, 0xd4, 0x8d, 0xd2, 0x0a, 0xbf,
0x18, 0x30, 0xe9, 0x31, 0x91, 0xac, 0x24, 0xcb, 0xf3, 0xe3, 0xd7, 0x99, 0x52, 0x59, 0x01, 0xb4,
0x57, 0xd2, 0xee, 0x17, 0xd5, 0xb2, 0x84, 0x56, 0xb3, 0xb2, 0x1e, 0x4e, 0x4d, 0xff, 0x4e, 0xd0,
0x64, 0x01, 0x06, 0x1f, 0x21, 0x5b, 0x0a, 0xcf, 0xf2, 0xad, 0xc0, 0x89, 0x6d, 0x29, 0x70, 0x80,
0x9e, 0x77, 0x2d, 0x34, 0x09, 0xe3, 0x5c, 0x75, 0x95, 0x4e, 0xa4, 0xf0, 0xec, 0x47, 0x78, 0xbb,
0x13, 0x1f, 0x3e, 0x82, 0x70, 0xc8, 0x23, 0x81, 0x09, 0xc2, 0x2d, 0x34, 0x4b, 0xc9, 0x61, 0x53,
0x9e, 0xac, 0x64, 0x77, 0xc5, 0xd6, 0xfe, 0x25, 0x42, 0xbc, 0x01, 0xa6, 0x41, 0x24, 0x4c, 0x7b,
0x4f, 0x7c, 0x2b, 0xd8, 0x9f, 0x1d, 0x93, 0xa1, 0x27, 0x19, 0x7b, 0x92, 0xfb, 0xb1, 0x67, 0xec,
0xac, 0xec, 0x50, 0x63, 0x1f, 0xed, 0x0b, 0x68, 0x79, 0x23, 0x6b, 0x2d, 0x55, 0xe5, 0x3d, 0xed,
0xdb, 0x6e, 0x46, 0xf8, 0x06, 0x1d, 0xe6, 0x60, 0x12, 0x56, 0x64, 0xaa, 0x91, 0xfa, 0xa1, 0xf4,
0x76, 0x7d, 0x2b, 0x38, 0x9a, 0x4d, 0xc9, 0x96, 0xe5, 0x90, 0x05, 0x18, 0x12, 0x8e, 0x66, 0x7c,
0x90, 0x83, 0xf9, 0x3f, 0xe1, 0x13, 0x84, 0xea, 0x2e, 0x2d, 0x24, 0x4f, 0x72, 0x30, 0xde, 0x5e,
0x7f, 0x93, 0x33, 0x24, 0x0b, 0x30, 0xd3, 0x39, 0x72, 0xd6, 0xee, 0x2b, 0xf4, 0x32, 0xfc, 0x7c,
0xf3, 0x2d, 0x8e, 0xee, 0x6f, 0xbf, 0x24, 0x3f, 0xbe, 0xde, 0x7d, 0xbf, 0xfe, 0x10, 0x7d, 0x8a,
0xae, 0x3f, 0xba, 0x3b, 0xf8, 0x00, 0x3d, 0x8b, 0xef, 0xc2, 0x64, 0x76, 0x76, 0xf1, 0xce, 0xb5,
0xc6, 0xe9, 0xe2, 0xec, 0xf2, 0xad, 0x6b, 0xcf, 0x1d, 0xb4, 0xd7, 0x76, 0xe9, 0x6f, 0xe0, 0x7a,
0xfe, 0xfe, 0xe7, 0x55, 0x26, 0xf5, 0x43, 0x97, 0x12, 0xae, 0x4a, 0x3a, 0x74, 0x3d, 0x1d, 0xde,
0x39, 0x53, 0xa7, 0x19, 0x54, 0xfd, 0x5e, 0xe8, 0x96, 0x0f, 0x70, 0x25, 0x59, 0x99, 0xee, 0xf6,
0xf8, 0xcd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41, 0xba, 0x65, 0x21, 0x22, 0x02, 0x00, 0x00,
}

624
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/key_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,624 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/key_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type KeyFormat int32
const (
// Privacy-Enhanced Mail (PEM) format. Default value.
KeyFormat_PEM_FILE KeyFormat = 0
)
var KeyFormat_name = map[int32]string{
0: "PEM_FILE",
}
var KeyFormat_value = map[string]int32{
"PEM_FILE": 0,
}
func (x KeyFormat) String() string {
return proto.EnumName(KeyFormat_name, int32(x))
}
func (KeyFormat) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{0}
}
type GetKeyRequest struct {
// ID of the Key resource to return.
// To get the ID use a [KeyService.List] request.
KeyId string `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
// Output format of the key.
Format KeyFormat `protobuf:"varint,2,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetKeyRequest) Reset() { *m = GetKeyRequest{} }
func (m *GetKeyRequest) String() string { return proto.CompactTextString(m) }
func (*GetKeyRequest) ProtoMessage() {}
func (*GetKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{0}
}
func (m *GetKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetKeyRequest.Unmarshal(m, b)
}
func (m *GetKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetKeyRequest.Marshal(b, m, deterministic)
}
func (dst *GetKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetKeyRequest.Merge(dst, src)
}
func (m *GetKeyRequest) XXX_Size() int {
return xxx_messageInfo_GetKeyRequest.Size(m)
}
func (m *GetKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetKeyRequest proto.InternalMessageInfo
func (m *GetKeyRequest) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func (m *GetKeyRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
type ListKeysRequest struct {
// Output format of the key.
Format KeyFormat `protobuf:"varint,1,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
// ID of the service account to list key pairs for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,2,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListKeysResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListKeysResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListKeysRequest) Reset() { *m = ListKeysRequest{} }
func (m *ListKeysRequest) String() string { return proto.CompactTextString(m) }
func (*ListKeysRequest) ProtoMessage() {}
func (*ListKeysRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{1}
}
func (m *ListKeysRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListKeysRequest.Unmarshal(m, b)
}
func (m *ListKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListKeysRequest.Marshal(b, m, deterministic)
}
func (dst *ListKeysRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListKeysRequest.Merge(dst, src)
}
func (m *ListKeysRequest) XXX_Size() int {
return xxx_messageInfo_ListKeysRequest.Size(m)
}
func (m *ListKeysRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListKeysRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListKeysRequest proto.InternalMessageInfo
func (m *ListKeysRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
func (m *ListKeysRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ListKeysRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListKeysRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListKeysResponse struct {
// List of Key resources.
Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListKeysRequest.page_size], use
// the [next_page_token] as the value
// for the [ListKeysRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListKeysResponse) Reset() { *m = ListKeysResponse{} }
func (m *ListKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListKeysResponse) ProtoMessage() {}
func (*ListKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{2}
}
func (m *ListKeysResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListKeysResponse.Unmarshal(m, b)
}
func (m *ListKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListKeysResponse.Marshal(b, m, deterministic)
}
func (dst *ListKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListKeysResponse.Merge(dst, src)
}
func (m *ListKeysResponse) XXX_Size() int {
return xxx_messageInfo_ListKeysResponse.Size(m)
}
func (m *ListKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListKeysResponse proto.InternalMessageInfo
func (m *ListKeysResponse) GetKeys() []*Key {
if m != nil {
return m.Keys
}
return nil
}
func (m *ListKeysResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateKeyRequest struct {
// ID of the service account to create a key pair for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Description of the key pair.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Output format of the key.
Format KeyFormat `protobuf:"varint,3,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
// An algorithm used to generate a key pair of the Key resource.
KeyAlgorithm Key_Algorithm `protobuf:"varint,4,opt,name=key_algorithm,json=keyAlgorithm,proto3,enum=yandex.cloud.iam.v1.Key_Algorithm" json:"key_algorithm,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateKeyRequest) Reset() { *m = CreateKeyRequest{} }
func (m *CreateKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateKeyRequest) ProtoMessage() {}
func (*CreateKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{3}
}
func (m *CreateKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateKeyRequest.Unmarshal(m, b)
}
func (m *CreateKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateKeyRequest.Marshal(b, m, deterministic)
}
func (dst *CreateKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateKeyRequest.Merge(dst, src)
}
func (m *CreateKeyRequest) XXX_Size() int {
return xxx_messageInfo_CreateKeyRequest.Size(m)
}
func (m *CreateKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateKeyRequest proto.InternalMessageInfo
func (m *CreateKeyRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *CreateKeyRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *CreateKeyRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
func (m *CreateKeyRequest) GetKeyAlgorithm() Key_Algorithm {
if m != nil {
return m.KeyAlgorithm
}
return Key_ALGORITHM_UNSPECIFIED
}
type CreateKeyResponse struct {
// Key resource.
Key *Key `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// A private key of the Key resource.
// This key must be stored securely.
PrivateKey string `protobuf:"bytes,2,opt,name=private_key,json=privateKey,proto3" json:"private_key,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateKeyResponse) Reset() { *m = CreateKeyResponse{} }
func (m *CreateKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateKeyResponse) ProtoMessage() {}
func (*CreateKeyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{4}
}
func (m *CreateKeyResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateKeyResponse.Unmarshal(m, b)
}
func (m *CreateKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateKeyResponse.Marshal(b, m, deterministic)
}
func (dst *CreateKeyResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateKeyResponse.Merge(dst, src)
}
func (m *CreateKeyResponse) XXX_Size() int {
return xxx_messageInfo_CreateKeyResponse.Size(m)
}
func (m *CreateKeyResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateKeyResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateKeyResponse proto.InternalMessageInfo
func (m *CreateKeyResponse) GetKey() *Key {
if m != nil {
return m.Key
}
return nil
}
func (m *CreateKeyResponse) GetPrivateKey() string {
if m != nil {
return m.PrivateKey
}
return ""
}
type DeleteKeyRequest struct {
// ID of the key to delete.
// To get key ID use a [KeyService.List] request.
KeyId string `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteKeyRequest) Reset() { *m = DeleteKeyRequest{} }
func (m *DeleteKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteKeyRequest) ProtoMessage() {}
func (*DeleteKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{5}
}
func (m *DeleteKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteKeyRequest.Unmarshal(m, b)
}
func (m *DeleteKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteKeyRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteKeyRequest.Merge(dst, src)
}
func (m *DeleteKeyRequest) XXX_Size() int {
return xxx_messageInfo_DeleteKeyRequest.Size(m)
}
func (m *DeleteKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteKeyRequest proto.InternalMessageInfo
func (m *DeleteKeyRequest) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func init() {
proto.RegisterType((*GetKeyRequest)(nil), "yandex.cloud.iam.v1.GetKeyRequest")
proto.RegisterType((*ListKeysRequest)(nil), "yandex.cloud.iam.v1.ListKeysRequest")
proto.RegisterType((*ListKeysResponse)(nil), "yandex.cloud.iam.v1.ListKeysResponse")
proto.RegisterType((*CreateKeyRequest)(nil), "yandex.cloud.iam.v1.CreateKeyRequest")
proto.RegisterType((*CreateKeyResponse)(nil), "yandex.cloud.iam.v1.CreateKeyResponse")
proto.RegisterType((*DeleteKeyRequest)(nil), "yandex.cloud.iam.v1.DeleteKeyRequest")
proto.RegisterEnum("yandex.cloud.iam.v1.KeyFormat", KeyFormat_name, KeyFormat_value)
}
// 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
// KeyServiceClient is the client API for KeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KeyServiceClient interface {
// Returns the specified Key resource.
//
// To get the list of available Key resources, make a [List] request.
Get(ctx context.Context, in *GetKeyRequest, opts ...grpc.CallOption) (*Key, error)
// Retrieves the list of Key resources for the specified service account.
List(ctx context.Context, in *ListKeysRequest, opts ...grpc.CallOption) (*ListKeysResponse, error)
// Creates a key pair for the specified service account.
Create(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*CreateKeyResponse, error)
// Deletes the specified key pair.
Delete(ctx context.Context, in *DeleteKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type keyServiceClient struct {
cc *grpc.ClientConn
}
func NewKeyServiceClient(cc *grpc.ClientConn) KeyServiceClient {
return &keyServiceClient{cc}
}
func (c *keyServiceClient) Get(ctx context.Context, in *GetKeyRequest, opts ...grpc.CallOption) (*Key, error) {
out := new(Key)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) List(ctx context.Context, in *ListKeysRequest, opts ...grpc.CallOption) (*ListKeysResponse, error) {
out := new(ListKeysResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) Create(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*CreateKeyResponse, error) {
out := new(CreateKeyResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) Delete(ctx context.Context, in *DeleteKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// KeyServiceServer is the server API for KeyService service.
type KeyServiceServer interface {
// Returns the specified Key resource.
//
// To get the list of available Key resources, make a [List] request.
Get(context.Context, *GetKeyRequest) (*Key, error)
// Retrieves the list of Key resources for the specified service account.
List(context.Context, *ListKeysRequest) (*ListKeysResponse, error)
// Creates a key pair for the specified service account.
Create(context.Context, *CreateKeyRequest) (*CreateKeyResponse, error)
// Deletes the specified key pair.
Delete(context.Context, *DeleteKeyRequest) (*empty.Empty, error)
}
func RegisterKeyServiceServer(s *grpc.Server, srv KeyServiceServer) {
s.RegisterService(&_KeyService_serviceDesc, srv)
}
func _KeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Get(ctx, req.(*GetKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListKeysRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).List(ctx, req.(*ListKeysRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Create(ctx, req.(*CreateKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Delete(ctx, req.(*DeleteKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
var _KeyService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.KeyService",
HandlerType: (*KeyServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _KeyService_Get_Handler,
},
{
MethodName: "List",
Handler: _KeyService_List_Handler,
},
{
MethodName: "Create",
Handler: _KeyService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _KeyService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/key_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/key_service.proto", fileDescriptor_key_service_16d84045cfb780d5)
}
var fileDescriptor_key_service_16d84045cfb780d5 = []byte{
// 685 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x41, 0x53, 0xd3, 0x5c,
0x14, 0xfd, 0x42, 0x4b, 0x87, 0x5e, 0x0a, 0x94, 0xf7, 0xa9, 0xd4, 0x2a, 0xda, 0x89, 0x82, 0x9d,
0x2a, 0x49, 0x5b, 0x07, 0x9c, 0x11, 0x58, 0x80, 0x02, 0xc3, 0x14, 0x67, 0x98, 0xe0, 0xca, 0x4d,
0x7d, 0x6d, 0x2f, 0xe5, 0x4d, 0x9b, 0xbc, 0x98, 0xbc, 0x76, 0x08, 0x8e, 0x1b, 0x97, 0x6c, 0xfd,
0x2d, 0xfe, 0x06, 0xd8, 0xeb, 0x4f, 0x70, 0xe1, 0x4f, 0x70, 0x5c, 0x39, 0x79, 0x49, 0x4b, 0x60,
0x52, 0x91, 0x65, 0x72, 0xcf, 0x3b, 0xe7, 0x9e, 0x73, 0xdf, 0xbb, 0xb0, 0xe0, 0x51, 0xab, 0x85,
0xc7, 0x7a, 0xb3, 0xcb, 0x7b, 0x2d, 0x9d, 0x51, 0x53, 0xef, 0x57, 0xf4, 0x0e, 0x7a, 0x75, 0x17,
0x9d, 0x3e, 0x6b, 0xa2, 0x66, 0x3b, 0x5c, 0x70, 0xf2, 0x7f, 0x00, 0xd3, 0x24, 0x4c, 0x63, 0xd4,
0xd4, 0xfa, 0x95, 0xfc, 0xfd, 0x36, 0xe7, 0xed, 0x2e, 0xea, 0xd4, 0x66, 0x3a, 0xb5, 0x2c, 0x2e,
0xa8, 0x60, 0xdc, 0x72, 0x83, 0x23, 0xf9, 0x7b, 0x61, 0x55, 0x7e, 0x35, 0x7a, 0x87, 0x3a, 0x9a,
0xb6, 0xf0, 0xc2, 0xe2, 0xfc, 0x08, 0xd9, 0xd8, 0x72, 0x9f, 0x76, 0x59, 0x4b, 0x72, 0x07, 0x65,
0xb5, 0x0b, 0x53, 0x3b, 0x28, 0x6a, 0xe8, 0x19, 0xf8, 0xa1, 0x87, 0xae, 0x20, 0x8f, 0x20, 0xe5,
0xf7, 0xcc, 0x5a, 0x39, 0xa5, 0xa0, 0x14, 0xd3, 0x9b, 0x99, 0x9f, 0x67, 0x15, 0xe5, 0xf4, 0xbc,
0x92, 0x5c, 0x5b, 0x5f, 0x2e, 0x1b, 0xe3, 0x1d, 0xf4, 0x76, 0x5b, 0x64, 0x05, 0x52, 0x87, 0xdc,
0x31, 0xa9, 0xc8, 0x8d, 0x15, 0x94, 0xe2, 0x74, 0xf5, 0x81, 0x16, 0x63, 0x4a, 0xab, 0xa1, 0xb7,
0x2d, 0x51, 0x46, 0x88, 0x56, 0xbf, 0x2b, 0x30, 0xb3, 0xc7, 0x5c, 0x5f, 0xcf, 0x1d, 0x08, 0x5e,
0x70, 0x29, 0x37, 0xe1, 0x22, 0x2b, 0x40, 0xc2, 0x60, 0xeb, 0xb4, 0xd9, 0xe4, 0x3d, 0x4b, 0xf8,
0x4d, 0x8f, 0xc9, 0xa6, 0x27, 0x86, 0x0d, 0x67, 0x43, 0xcc, 0x46, 0x00, 0xd9, 0x6d, 0x91, 0x27,
0x90, 0xb6, 0x69, 0x1b, 0xeb, 0x2e, 0x3b, 0xc1, 0x5c, 0xa2, 0xa0, 0x14, 0x13, 0x9b, 0xf0, 0xfb,
0xac, 0x92, 0x5a, 0x5b, 0xaf, 0x94, 0xcb, 0x65, 0x63, 0xc2, 0x2f, 0x1e, 0xb0, 0x13, 0x24, 0x45,
0x00, 0x09, 0x14, 0xbc, 0x83, 0x56, 0x2e, 0x29, 0x89, 0xd3, 0xa7, 0xe7, 0x95, 0x71, 0x89, 0x34,
0x24, 0xcb, 0x5b, 0xbf, 0xa6, 0x1e, 0x41, 0xf6, 0xc2, 0x95, 0x6b, 0x73, 0xcb, 0x45, 0xf2, 0x0c,
0x92, 0x1d, 0xf4, 0xdc, 0x9c, 0x52, 0x48, 0x14, 0x27, 0xab, 0xb9, 0x51, 0xa6, 0x0c, 0x89, 0x22,
0x8b, 0x30, 0x63, 0xe1, 0xb1, 0xa8, 0x47, 0x04, 0xa5, 0x13, 0x63, 0xca, 0xff, 0xbd, 0x3f, 0x54,
0xfa, 0xa5, 0x40, 0xf6, 0x95, 0x83, 0x54, 0x60, 0x64, 0x64, 0xf1, 0x49, 0x28, 0xd7, 0x26, 0xf1,
0x14, 0x26, 0x5b, 0xe8, 0x36, 0x1d, 0x66, 0xfb, 0x17, 0x22, 0x8c, 0x2e, 0x74, 0x58, 0x5d, 0x5e,
0x31, 0xa2, 0xd5, 0xc8, 0x98, 0x12, 0x37, 0x1a, 0xd3, 0x0e, 0x4c, 0xf9, 0xf7, 0x89, 0x76, 0xdb,
0xdc, 0x61, 0xe2, 0xc8, 0x94, 0x41, 0x4e, 0x57, 0xd5, 0x51, 0xc7, 0xb5, 0x8d, 0x01, 0xd2, 0xc8,
0x74, 0xd0, 0x1b, 0x7e, 0xa9, 0xef, 0x61, 0x36, 0xe2, 0x3c, 0x4c, 0xb9, 0x04, 0x89, 0x0e, 0x7a,
0xd2, 0xeb, 0xdf, 0x42, 0xf6, 0x41, 0xe4, 0x21, 0x4c, 0xda, 0x0e, 0xeb, 0x53, 0x81, 0x75, 0xff,
0x4c, 0x90, 0x2f, 0x84, 0xbf, 0x6a, 0xe8, 0xa9, 0x2f, 0x20, 0xfb, 0x1a, 0xbb, 0x78, 0x29, 0xdb,
0x7f, 0x79, 0x0e, 0xa5, 0xbb, 0x90, 0x1e, 0x1a, 0x27, 0x19, 0x98, 0xd8, 0xdf, 0x7a, 0x53, 0xdf,
0xde, 0xdd, 0xdb, 0xca, 0xfe, 0x57, 0xfd, 0x9a, 0x00, 0xa8, 0xa1, 0x77, 0x10, 0x64, 0x4f, 0x1a,
0x90, 0xd8, 0x41, 0x41, 0xe2, 0xdd, 0x5f, 0x7a, 0x88, 0xf9, 0x91, 0x6e, 0xd4, 0xf9, 0xcf, 0xdf,
0x7e, 0x7c, 0x19, 0x9b, 0x23, 0xb7, 0x23, 0xaf, 0xdd, 0xd5, 0x3f, 0x06, 0x7d, 0x7e, 0x22, 0x0c,
0x92, 0xfe, 0x6d, 0x24, 0x8f, 0x63, 0x09, 0xae, 0x3c, 0xbf, 0xfc, 0xc2, 0x35, 0xa8, 0x20, 0x68,
0xf5, 0x96, 0xd4, 0x9c, 0x26, 0x99, 0xa8, 0x26, 0xb1, 0x21, 0x15, 0xcc, 0x84, 0xc4, 0xd3, 0x5c,
0xbd, 0xaa, 0xf9, 0xc5, 0xeb, 0x60, 0xa1, 0xdc, 0x9c, 0x94, 0x9b, 0x55, 0x2f, 0xc9, 0xbd, 0x54,
0x4a, 0xe4, 0x10, 0x52, 0xc1, 0x8c, 0x46, 0x28, 0x5e, 0x1d, 0x60, 0xfe, 0x8e, 0x16, 0x2c, 0x4f,
0x6d, 0xb0, 0x3c, 0xb5, 0x2d, 0x7f, 0x79, 0x0e, 0x42, 0x2c, 0xc5, 0x87, 0xb8, 0xb9, 0xfe, 0x6e,
0xb5, 0xcd, 0xc4, 0x51, 0xaf, 0xa1, 0x35, 0xb9, 0xa9, 0x07, 0x4a, 0x4b, 0xc1, 0x0e, 0x6d, 0xf3,
0xa5, 0x36, 0x5a, 0x92, 0x4e, 0x8f, 0xd9, 0xbd, 0xab, 0x8c, 0x9a, 0x8d, 0x94, 0x2c, 0x3f, 0xff,
0x13, 0x00, 0x00, 0xff, 0xff, 0xca, 0x77, 0xed, 0xa5, 0x14, 0x06, 0x00, 0x00,
}

90
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/role.pb.go generated vendored Normal file
View File

@ -0,0 +1,90 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/role.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A Role resource. For more information, see [Roles](/docs/iam/concepts/access-control/roles).
type Role struct {
// ID of the role.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Description of the role. 0-256 characters long.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Role) Reset() { *m = Role{} }
func (m *Role) String() string { return proto.CompactTextString(m) }
func (*Role) ProtoMessage() {}
func (*Role) Descriptor() ([]byte, []int) {
return fileDescriptor_role_656bcd2fea39e7f2, []int{0}
}
func (m *Role) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Role.Unmarshal(m, b)
}
func (m *Role) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Role.Marshal(b, m, deterministic)
}
func (dst *Role) XXX_Merge(src proto.Message) {
xxx_messageInfo_Role.Merge(dst, src)
}
func (m *Role) XXX_Size() int {
return xxx_messageInfo_Role.Size(m)
}
func (m *Role) XXX_DiscardUnknown() {
xxx_messageInfo_Role.DiscardUnknown(m)
}
var xxx_messageInfo_Role proto.InternalMessageInfo
func (m *Role) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Role) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*Role)(nil), "yandex.cloud.iam.v1.Role")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/role.proto", fileDescriptor_role_656bcd2fea39e7f2)
}
var fileDescriptor_role_656bcd2fea39e7f2 = []byte{
// 155 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x2f, 0xca, 0xcf, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xc8, 0xeb, 0x81,
0xe5, 0xf5, 0x32, 0x13, 0x73, 0xf5, 0xca, 0x0c, 0x95, 0x2c, 0xb8, 0x58, 0x82, 0xf2, 0x73, 0x52,
0x85, 0xf8, 0xb8, 0x98, 0x32, 0x53, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x98, 0x32, 0x53,
0x84, 0x14, 0xb8, 0xb8, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, 0x0b, 0x4a, 0x32, 0xf3, 0xf3, 0x24,
0x98, 0xc0, 0x12, 0xc8, 0x42, 0x4e, 0xb6, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a,
0xc9, 0xf9, 0xb9, 0xfa, 0x10, 0xb3, 0x75, 0x21, 0x76, 0xa7, 0xe7, 0xeb, 0xa6, 0xa7, 0xe6, 0x81,
0x6d, 0xd5, 0xc7, 0xe2, 0x28, 0xeb, 0xcc, 0xc4, 0xdc, 0x24, 0x36, 0xb0, 0xb4, 0x31, 0x20, 0x00,
0x00, 0xff, 0xff, 0x48, 0x72, 0x28, 0xb9, 0xb6, 0x00, 0x00, 0x00,
}

336
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/role_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,336 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/role_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetRoleRequest struct {
// ID of the Role resource to return.
// To get the role ID, use a [RoleService.List] request.
RoleId string `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRoleRequest) Reset() { *m = GetRoleRequest{} }
func (m *GetRoleRequest) String() string { return proto.CompactTextString(m) }
func (*GetRoleRequest) ProtoMessage() {}
func (*GetRoleRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{0}
}
func (m *GetRoleRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetRoleRequest.Unmarshal(m, b)
}
func (m *GetRoleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetRoleRequest.Marshal(b, m, deterministic)
}
func (dst *GetRoleRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetRoleRequest.Merge(dst, src)
}
func (m *GetRoleRequest) XXX_Size() int {
return xxx_messageInfo_GetRoleRequest.Size(m)
}
func (m *GetRoleRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetRoleRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetRoleRequest proto.InternalMessageInfo
func (m *GetRoleRequest) GetRoleId() string {
if m != nil {
return m.RoleId
}
return ""
}
type ListRolesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListRolesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token]
// to the [ListRolesResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
Filter string `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRolesRequest) Reset() { *m = ListRolesRequest{} }
func (m *ListRolesRequest) String() string { return proto.CompactTextString(m) }
func (*ListRolesRequest) ProtoMessage() {}
func (*ListRolesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{1}
}
func (m *ListRolesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRolesRequest.Unmarshal(m, b)
}
func (m *ListRolesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRolesRequest.Marshal(b, m, deterministic)
}
func (dst *ListRolesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRolesRequest.Merge(dst, src)
}
func (m *ListRolesRequest) XXX_Size() int {
return xxx_messageInfo_ListRolesRequest.Size(m)
}
func (m *ListRolesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListRolesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListRolesRequest proto.InternalMessageInfo
func (m *ListRolesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListRolesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListRolesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
type ListRolesResponse struct {
// List of Role resources.
Roles []*Role `protobuf:"bytes,1,rep,name=roles,proto3" json:"roles,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListRolesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListRolesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRolesResponse) Reset() { *m = ListRolesResponse{} }
func (m *ListRolesResponse) String() string { return proto.CompactTextString(m) }
func (*ListRolesResponse) ProtoMessage() {}
func (*ListRolesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{2}
}
func (m *ListRolesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRolesResponse.Unmarshal(m, b)
}
func (m *ListRolesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRolesResponse.Marshal(b, m, deterministic)
}
func (dst *ListRolesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRolesResponse.Merge(dst, src)
}
func (m *ListRolesResponse) XXX_Size() int {
return xxx_messageInfo_ListRolesResponse.Size(m)
}
func (m *ListRolesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListRolesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListRolesResponse proto.InternalMessageInfo
func (m *ListRolesResponse) GetRoles() []*Role {
if m != nil {
return m.Roles
}
return nil
}
func (m *ListRolesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetRoleRequest)(nil), "yandex.cloud.iam.v1.GetRoleRequest")
proto.RegisterType((*ListRolesRequest)(nil), "yandex.cloud.iam.v1.ListRolesRequest")
proto.RegisterType((*ListRolesResponse)(nil), "yandex.cloud.iam.v1.ListRolesResponse")
}
// 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
// RoleServiceClient is the client API for RoleService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RoleServiceClient interface {
// Returns the specified Role resource.
//
// To get the list of available Role resources, use a [List] request.
Get(ctx context.Context, in *GetRoleRequest, opts ...grpc.CallOption) (*Role, error)
// Retrieves the list of Role resources.
List(ctx context.Context, in *ListRolesRequest, opts ...grpc.CallOption) (*ListRolesResponse, error)
}
type roleServiceClient struct {
cc *grpc.ClientConn
}
func NewRoleServiceClient(cc *grpc.ClientConn) RoleServiceClient {
return &roleServiceClient{cc}
}
func (c *roleServiceClient) Get(ctx context.Context, in *GetRoleRequest, opts ...grpc.CallOption) (*Role, error) {
out := new(Role)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.RoleService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *roleServiceClient) List(ctx context.Context, in *ListRolesRequest, opts ...grpc.CallOption) (*ListRolesResponse, error) {
out := new(ListRolesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.RoleService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RoleServiceServer is the server API for RoleService service.
type RoleServiceServer interface {
// Returns the specified Role resource.
//
// To get the list of available Role resources, use a [List] request.
Get(context.Context, *GetRoleRequest) (*Role, error)
// Retrieves the list of Role resources.
List(context.Context, *ListRolesRequest) (*ListRolesResponse, error)
}
func RegisterRoleServiceServer(s *grpc.Server, srv RoleServiceServer) {
s.RegisterService(&_RoleService_serviceDesc, srv)
}
func _RoleService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRoleRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RoleServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.RoleService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RoleServiceServer).Get(ctx, req.(*GetRoleRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RoleService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListRolesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RoleServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.RoleService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RoleServiceServer).List(ctx, req.(*ListRolesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RoleService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.RoleService",
HandlerType: (*RoleServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _RoleService_Get_Handler,
},
{
MethodName: "List",
Handler: _RoleService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/role_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/role_service.proto", fileDescriptor_role_service_e49934510c2989c5)
}
var fileDescriptor_role_service_e49934510c2989c5 = []byte{
// 431 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x3f, 0x6f, 0xd3, 0x40,
0x14, 0x97, 0x9b, 0x36, 0x90, 0x57, 0x4a, 0xe1, 0x10, 0xc2, 0xb5, 0xf8, 0x53, 0x19, 0x35, 0x64,
0xa9, 0xcf, 0x2e, 0x42, 0x0c, 0x6d, 0x96, 0x2c, 0x15, 0x12, 0x03, 0x72, 0x99, 0x58, 0xa2, 0x6b,
0xfc, 0x6a, 0x4e, 0x9c, 0xef, 0x8c, 0xef, 0x62, 0x95, 0x22, 0x16, 0x36, 0xb2, 0xf2, 0xa1, 0x9a,
0x9d, 0x8f, 0x00, 0x03, 0x9f, 0x81, 0x09, 0xf9, 0x2e, 0x45, 0x4d, 0xe5, 0x8a, 0xf5, 0x7e, 0x7f,
0xef, 0xbd, 0x07, 0xfd, 0x4f, 0x4c, 0x66, 0x78, 0x4a, 0x27, 0x42, 0x4d, 0x33, 0xca, 0x59, 0x41,
0xeb, 0x84, 0x56, 0x4a, 0xe0, 0x58, 0x63, 0x55, 0xf3, 0x09, 0x46, 0x65, 0xa5, 0x8c, 0x22, 0xf7,
0x1c, 0x2f, 0xb2, 0xbc, 0x88, 0xb3, 0x22, 0xaa, 0x93, 0xe0, 0x61, 0xae, 0x54, 0x2e, 0x90, 0xb2,
0x92, 0x53, 0x26, 0xa5, 0x32, 0xcc, 0x70, 0x25, 0xb5, 0x93, 0x04, 0x8f, 0x96, 0xac, 0x6b, 0x26,
0x78, 0x66, 0xf1, 0x05, 0xfc, 0xf8, 0xba, 0x64, 0x87, 0x87, 0x2f, 0xe1, 0xf6, 0x21, 0x9a, 0x54,
0x09, 0x4c, 0xf1, 0xe3, 0x14, 0xb5, 0x21, 0x3b, 0x70, 0xc3, 0x36, 0xe3, 0x99, 0xef, 0x6d, 0x7b,
0x83, 0xde, 0xe8, 0xd6, 0xef, 0xf3, 0xc4, 0x9b, 0xcd, 0x93, 0xd5, 0x83, 0xe1, 0x8b, 0x38, 0xed,
0x36, 0xe0, 0xab, 0x2c, 0xfc, 0xe6, 0xc1, 0x9d, 0xd7, 0x5c, 0x5b, 0xa9, 0xbe, 0xd0, 0x3e, 0x83,
0x5e, 0xc9, 0x72, 0x1c, 0x6b, 0x7e, 0x86, 0x56, 0xdd, 0x19, 0xc1, 0x9f, 0xf3, 0xa4, 0x7b, 0x30,
0x4c, 0xe2, 0x38, 0x4e, 0x6f, 0x36, 0xe0, 0x11, 0x3f, 0x43, 0x32, 0x00, 0xb0, 0x44, 0xa3, 0x3e,
0xa0, 0xf4, 0x57, 0x6c, 0x4e, 0x6f, 0x36, 0x4f, 0xd6, 0x2c, 0x33, 0xb5, 0x2e, 0x6f, 0x1b, 0x8c,
0x84, 0xd0, 0x3d, 0xe1, 0xc2, 0x60, 0xe5, 0x77, 0x2c, 0x0b, 0x66, 0xf3, 0x7f, 0x7e, 0x0b, 0x24,
0x14, 0x70, 0xf7, 0x52, 0x15, 0x5d, 0x2a, 0xa9, 0x91, 0x50, 0x58, 0x6b, 0xaa, 0x6a, 0xdf, 0xdb,
0xee, 0x0c, 0xd6, 0xf7, 0xb6, 0xa2, 0x96, 0xd9, 0x46, 0xf6, 0xe3, 0x8e, 0x47, 0xfa, 0xb0, 0x29,
0xf1, 0xd4, 0x8c, 0xaf, 0x16, 0x4b, 0x37, 0x9a, 0xe7, 0x37, 0x17, 0x8d, 0xf6, 0x7e, 0x7a, 0xb0,
0xde, 0xe8, 0x8e, 0xdc, 0xea, 0xc8, 0x09, 0x74, 0x0e, 0xd1, 0x90, 0xa7, 0xad, 0x01, 0xcb, 0xc3,
0x0d, 0xae, 0x6f, 0x11, 0x3e, 0xf9, 0xfa, 0xe3, 0xd7, 0xf7, 0x95, 0x2d, 0xf2, 0xe0, 0xf2, 0x96,
0x34, 0xfd, 0xbc, 0x58, 0xc6, 0x17, 0x22, 0x60, 0xb5, 0xf9, 0x25, 0xd9, 0x69, 0xf5, 0xb8, 0xba,
0x8b, 0xa0, 0xff, 0x3f, 0x9a, 0x9b, 0x53, 0x78, 0xdf, 0xe6, 0x6e, 0x92, 0x8d, 0xa5, 0xdc, 0xd1,
0xf0, 0xdd, 0x7e, 0xce, 0xcd, 0xfb, 0xe9, 0x71, 0x34, 0x51, 0x05, 0x75, 0x56, 0xbb, 0xee, 0x8a,
0x72, 0xb5, 0x9b, 0xa3, 0xb4, 0xf7, 0x43, 0x5b, 0xce, 0x6b, 0x9f, 0xb3, 0xe2, 0xb8, 0x6b, 0xe1,
0xe7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x85, 0xbc, 0xc9, 0x90, 0xfa, 0x02, 0x00, 0x00,
}

127
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/service_account.pb.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/service_account.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A ServiceAccount resource. For more information, see [Service accounts](/docs/iam/concepts/users/service-accounts).
type ServiceAccount struct {
// ID of the service account.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the service account belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the service account.
// The name is unique within the cloud. 3-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the service account. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ServiceAccount) Reset() { *m = ServiceAccount{} }
func (m *ServiceAccount) String() string { return proto.CompactTextString(m) }
func (*ServiceAccount) ProtoMessage() {}
func (*ServiceAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_service_account_ff4a14d624b4e70e, []int{0}
}
func (m *ServiceAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ServiceAccount.Unmarshal(m, b)
}
func (m *ServiceAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ServiceAccount.Marshal(b, m, deterministic)
}
func (dst *ServiceAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_ServiceAccount.Merge(dst, src)
}
func (m *ServiceAccount) XXX_Size() int {
return xxx_messageInfo_ServiceAccount.Size(m)
}
func (m *ServiceAccount) XXX_DiscardUnknown() {
xxx_messageInfo_ServiceAccount.DiscardUnknown(m)
}
var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo
func (m *ServiceAccount) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ServiceAccount) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ServiceAccount) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *ServiceAccount) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ServiceAccount) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ServiceAccount)(nil), "yandex.cloud.iam.v1.ServiceAccount")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/service_account.proto", fileDescriptor_service_account_ff4a14d624b4e70e)
}
var fileDescriptor_service_account_ff4a14d624b4e70e = []byte{
// 269 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4b, 0xc3, 0x30,
0x18, 0xc5, 0x69, 0x9d, 0x62, 0x33, 0xd8, 0x21, 0x5e, 0x4a, 0x45, 0x2c, 0x9e, 0xe6, 0x61, 0x09,
0xd3, 0x93, 0x0c, 0x0f, 0xf3, 0xe6, 0x75, 0x7a, 0xf2, 0x52, 0xbe, 0x26, 0xdf, 0xea, 0x07, 0x4d,
0x53, 0xd2, 0xb4, 0xe8, 0x3f, 0xe5, 0xdf, 0x28, 0x26, 0x0e, 0x14, 0x76, 0x0b, 0xef, 0xbd, 0xe4,
0xfd, 0x5e, 0xd8, 0xed, 0x27, 0x74, 0x1a, 0x3f, 0xa4, 0x6a, 0xed, 0xa8, 0x25, 0x81, 0x91, 0xd3,
0x5a, 0x0e, 0xe8, 0x26, 0x52, 0x58, 0x81, 0x52, 0x76, 0xec, 0xbc, 0xe8, 0x9d, 0xf5, 0x96, 0x5f,
0xc4, 0xa8, 0x08, 0x51, 0x41, 0x60, 0xc4, 0xb4, 0x2e, 0xae, 0x1b, 0x6b, 0x9b, 0x16, 0x65, 0x88,
0xd4, 0xe3, 0x5e, 0x7a, 0x32, 0x38, 0x78, 0x30, 0x7d, 0xbc, 0x55, 0x5c, 0xfd, 0x2b, 0x98, 0xa0,
0x25, 0x0d, 0x9e, 0x6c, 0x17, 0xed, 0x9b, 0xaf, 0x84, 0x2d, 0x5e, 0x62, 0xdd, 0x36, 0xb6, 0xf1,
0x05, 0x4b, 0x49, 0xe7, 0x49, 0x99, 0x2c, 0xb3, 0x5d, 0x4a, 0x9a, 0x5f, 0xb2, 0x6c, 0x6f, 0x5b,
0x8d, 0xae, 0x22, 0x9d, 0xa7, 0x41, 0x3e, 0x8f, 0xc2, 0xb3, 0xe6, 0x0f, 0x8c, 0x29, 0x87, 0xe0,
0x51, 0x57, 0xe0, 0xf3, 0x93, 0x32, 0x59, 0xce, 0xef, 0x0a, 0x11, 0xa1, 0xc4, 0x01, 0x4a, 0xbc,
0x1e, 0xa0, 0x76, 0xd9, 0x6f, 0x7a, 0xeb, 0x39, 0x67, 0xb3, 0x0e, 0x0c, 0xe6, 0xb3, 0xf0, 0x64,
0x38, 0xf3, 0x92, 0xcd, 0x35, 0x0e, 0xca, 0x51, 0xff, 0xc3, 0x98, 0x9f, 0x06, 0xeb, 0xaf, 0xf4,
0xf4, 0xf8, 0xb6, 0x69, 0xc8, 0xbf, 0x8f, 0xb5, 0x50, 0xd6, 0xc8, 0x38, 0x6e, 0x15, 0xc7, 0x35,
0x76, 0xd5, 0x60, 0x17, 0x4a, 0xe5, 0x91, 0x6f, 0xdd, 0x10, 0x98, 0xfa, 0x2c, 0xd8, 0xf7, 0xdf,
0x01, 0x00, 0x00, 0xff, 0xff, 0x65, 0x42, 0x1f, 0xbf, 0x78, 0x01, 0x00, 0x00,
}

1041
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/service_account_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

221
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/user_account.pb.go generated vendored Normal file
View File

@ -0,0 +1,221 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/user_account.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// Currently represents only [Yandex.Passport account](/docs/iam/concepts/#passport).
type UserAccount struct {
// ID of the user account.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Types that are valid to be assigned to UserAccount:
// *UserAccount_YandexPassportUserAccount
UserAccount isUserAccount_UserAccount `protobuf_oneof:"user_account"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserAccount) Reset() { *m = UserAccount{} }
func (m *UserAccount) String() string { return proto.CompactTextString(m) }
func (*UserAccount) ProtoMessage() {}
func (*UserAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_ced378befb1b3d2f, []int{0}
}
func (m *UserAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserAccount.Unmarshal(m, b)
}
func (m *UserAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserAccount.Marshal(b, m, deterministic)
}
func (dst *UserAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserAccount.Merge(dst, src)
}
func (m *UserAccount) XXX_Size() int {
return xxx_messageInfo_UserAccount.Size(m)
}
func (m *UserAccount) XXX_DiscardUnknown() {
xxx_messageInfo_UserAccount.DiscardUnknown(m)
}
var xxx_messageInfo_UserAccount proto.InternalMessageInfo
func (m *UserAccount) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type isUserAccount_UserAccount interface {
isUserAccount_UserAccount()
}
type UserAccount_YandexPassportUserAccount struct {
YandexPassportUserAccount *YandexPassportUserAccount `protobuf:"bytes,2,opt,name=yandex_passport_user_account,json=yandexPassportUserAccount,proto3,oneof"`
}
func (*UserAccount_YandexPassportUserAccount) isUserAccount_UserAccount() {}
func (m *UserAccount) GetUserAccount() isUserAccount_UserAccount {
if m != nil {
return m.UserAccount
}
return nil
}
func (m *UserAccount) GetYandexPassportUserAccount() *YandexPassportUserAccount {
if x, ok := m.GetUserAccount().(*UserAccount_YandexPassportUserAccount); ok {
return x.YandexPassportUserAccount
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*UserAccount) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _UserAccount_OneofMarshaler, _UserAccount_OneofUnmarshaler, _UserAccount_OneofSizer, []interface{}{
(*UserAccount_YandexPassportUserAccount)(nil),
}
}
func _UserAccount_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*UserAccount)
// user_account
switch x := m.UserAccount.(type) {
case *UserAccount_YandexPassportUserAccount:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.YandexPassportUserAccount); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("UserAccount.UserAccount has unexpected type %T", x)
}
return nil
}
func _UserAccount_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*UserAccount)
switch tag {
case 2: // user_account.yandex_passport_user_account
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(YandexPassportUserAccount)
err := b.DecodeMessage(msg)
m.UserAccount = &UserAccount_YandexPassportUserAccount{msg}
return true, err
default:
return false, nil
}
}
func _UserAccount_OneofSizer(msg proto.Message) (n int) {
m := msg.(*UserAccount)
// user_account
switch x := m.UserAccount.(type) {
case *UserAccount_YandexPassportUserAccount:
s := proto.Size(x.YandexPassportUserAccount)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A YandexPassportUserAccount resource. For more information, see [Yandex.Passport account](/docs/iam/concepts/#passport).
type YandexPassportUserAccount struct {
// Login of the Yandex.Passport user account.
Login string `protobuf:"bytes,1,opt,name=login,proto3" json:"login,omitempty"`
// Default email of the Yandex.Passport user account.
DefaultEmail string `protobuf:"bytes,2,opt,name=default_email,json=defaultEmail,proto3" json:"default_email,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *YandexPassportUserAccount) Reset() { *m = YandexPassportUserAccount{} }
func (m *YandexPassportUserAccount) String() string { return proto.CompactTextString(m) }
func (*YandexPassportUserAccount) ProtoMessage() {}
func (*YandexPassportUserAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_ced378befb1b3d2f, []int{1}
}
func (m *YandexPassportUserAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_YandexPassportUserAccount.Unmarshal(m, b)
}
func (m *YandexPassportUserAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_YandexPassportUserAccount.Marshal(b, m, deterministic)
}
func (dst *YandexPassportUserAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_YandexPassportUserAccount.Merge(dst, src)
}
func (m *YandexPassportUserAccount) XXX_Size() int {
return xxx_messageInfo_YandexPassportUserAccount.Size(m)
}
func (m *YandexPassportUserAccount) XXX_DiscardUnknown() {
xxx_messageInfo_YandexPassportUserAccount.DiscardUnknown(m)
}
var xxx_messageInfo_YandexPassportUserAccount proto.InternalMessageInfo
func (m *YandexPassportUserAccount) GetLogin() string {
if m != nil {
return m.Login
}
return ""
}
func (m *YandexPassportUserAccount) GetDefaultEmail() string {
if m != nil {
return m.DefaultEmail
}
return ""
}
func init() {
proto.RegisterType((*UserAccount)(nil), "yandex.cloud.iam.v1.UserAccount")
proto.RegisterType((*YandexPassportUserAccount)(nil), "yandex.cloud.iam.v1.YandexPassportUserAccount")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/user_account.proto", fileDescriptor_user_account_ced378befb1b3d2f)
}
var fileDescriptor_user_account_ced378befb1b3d2f = []byte{
// 258 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0xcf, 0x4b, 0xc3, 0x30,
0x14, 0xb6, 0x05, 0x85, 0x65, 0x73, 0x87, 0xe8, 0x61, 0x13, 0x85, 0x31, 0x41, 0x76, 0x59, 0xc2,
0xf4, 0x38, 0x3c, 0x38, 0x10, 0x3c, 0x4a, 0x41, 0x41, 0x2f, 0xe5, 0xad, 0x89, 0xf5, 0x41, 0x7e,
0xd4, 0x36, 0x29, 0xee, 0xbf, 0xf1, 0x4f, 0x15, 0x93, 0x1e, 0x2a, 0x6c, 0xc7, 0xf7, 0xbd, 0xef,
0x17, 0x1f, 0xb9, 0xd9, 0x81, 0x11, 0xf2, 0x9b, 0x17, 0xca, 0x7a, 0xc1, 0x11, 0x34, 0x6f, 0x57,
0xdc, 0x37, 0xb2, 0xce, 0xa1, 0x28, 0xac, 0x37, 0x8e, 0x55, 0xb5, 0x75, 0x96, 0x9e, 0x45, 0x1e,
0x0b, 0x3c, 0x86, 0xa0, 0x59, 0xbb, 0xba, 0xb8, 0xfa, 0x27, 0x6e, 0x41, 0xa1, 0x00, 0x87, 0xd6,
0x44, 0xcd, 0xfc, 0x27, 0x21, 0xc3, 0x97, 0x46, 0xd6, 0x0f, 0xd1, 0x89, 0x8e, 0x49, 0x8a, 0x62,
0x92, 0xcc, 0x92, 0xc5, 0x20, 0x4b, 0x51, 0xd0, 0x2f, 0x72, 0x19, 0x0d, 0xf2, 0x0a, 0x9a, 0xa6,
0xb2, 0xb5, 0xcb, 0xfb, 0xc9, 0x93, 0x74, 0x96, 0x2c, 0x86, 0xb7, 0x8c, 0xed, 0x89, 0x66, 0x6f,
0x01, 0x7b, 0xee, 0x74, 0xbd, 0x94, 0xa7, 0xa3, 0x6c, 0xba, 0x3b, 0xf4, 0xdc, 0x8c, 0xc9, 0xa8,
0x1f, 0x31, 0x7f, 0x25, 0xd3, 0x83, 0x4e, 0xf4, 0x9c, 0x1c, 0x2b, 0x5b, 0xa2, 0xe9, 0x2a, 0xc7,
0x83, 0x5e, 0x93, 0x53, 0x21, 0x3f, 0xc0, 0x2b, 0x97, 0x4b, 0x0d, 0xa8, 0x42, 0xcd, 0x41, 0x36,
0xea, 0xc0, 0xc7, 0x3f, 0x6c, 0x73, 0xff, 0xbe, 0x2e, 0xd1, 0x7d, 0xfa, 0x2d, 0x2b, 0xac, 0xe6,
0xb1, 0xcf, 0x32, 0xce, 0x54, 0xda, 0x65, 0x29, 0x4d, 0x58, 0x88, 0xef, 0x19, 0x7f, 0x8d, 0xa0,
0xb7, 0x27, 0xe1, 0x7d, 0xf7, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xdc, 0xc7, 0x2e, 0x9e, 0x01,
0x00, 0x00,
}

169
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/user_account_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,169 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/user_account_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetUserAccountRequest struct {
// ID of the UserAccount resource to return.
UserAccountId string `protobuf:"bytes,1,opt,name=user_account_id,json=userAccountId,proto3" json:"user_account_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetUserAccountRequest) Reset() { *m = GetUserAccountRequest{} }
func (m *GetUserAccountRequest) String() string { return proto.CompactTextString(m) }
func (*GetUserAccountRequest) ProtoMessage() {}
func (*GetUserAccountRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_service_d671b5c11a2773d8, []int{0}
}
func (m *GetUserAccountRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserAccountRequest.Unmarshal(m, b)
}
func (m *GetUserAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetUserAccountRequest.Marshal(b, m, deterministic)
}
func (dst *GetUserAccountRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetUserAccountRequest.Merge(dst, src)
}
func (m *GetUserAccountRequest) XXX_Size() int {
return xxx_messageInfo_GetUserAccountRequest.Size(m)
}
func (m *GetUserAccountRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetUserAccountRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetUserAccountRequest proto.InternalMessageInfo
func (m *GetUserAccountRequest) GetUserAccountId() string {
if m != nil {
return m.UserAccountId
}
return ""
}
func init() {
proto.RegisterType((*GetUserAccountRequest)(nil), "yandex.cloud.iam.v1.GetUserAccountRequest")
}
// 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
// UserAccountServiceClient is the client API for UserAccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type UserAccountServiceClient interface {
// Returns the specified UserAccount resource.
Get(ctx context.Context, in *GetUserAccountRequest, opts ...grpc.CallOption) (*UserAccount, error)
}
type userAccountServiceClient struct {
cc *grpc.ClientConn
}
func NewUserAccountServiceClient(cc *grpc.ClientConn) UserAccountServiceClient {
return &userAccountServiceClient{cc}
}
func (c *userAccountServiceClient) Get(ctx context.Context, in *GetUserAccountRequest, opts ...grpc.CallOption) (*UserAccount, error) {
out := new(UserAccount)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.UserAccountService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// UserAccountServiceServer is the server API for UserAccountService service.
type UserAccountServiceServer interface {
// Returns the specified UserAccount resource.
Get(context.Context, *GetUserAccountRequest) (*UserAccount, error)
}
func RegisterUserAccountServiceServer(s *grpc.Server, srv UserAccountServiceServer) {
s.RegisterService(&_UserAccountService_serviceDesc, srv)
}
func _UserAccountService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserAccountRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(UserAccountServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.UserAccountService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(UserAccountServiceServer).Get(ctx, req.(*GetUserAccountRequest))
}
return interceptor(ctx, in, info, handler)
}
var _UserAccountService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.UserAccountService",
HandlerType: (*UserAccountServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _UserAccountService_Get_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/user_account_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/user_account_service.proto", fileDescriptor_user_account_service_d671b5c11a2773d8)
}
var fileDescriptor_user_account_service_d671b5c11a2773d8 = []byte{
// 284 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x2f, 0x2d, 0x4e, 0x2d, 0x8a, 0x4f, 0x4c, 0x4e, 0xce, 0x2f, 0xcd, 0x2b, 0x89, 0x2f, 0x4e, 0x2d,
0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xa8, 0xd7, 0x03,
0xab, 0xd7, 0xcb, 0x4c, 0xcc, 0xd5, 0x2b, 0x33, 0x94, 0x92, 0x49, 0xcf, 0xcf, 0x4f, 0xcf, 0x49,
0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b,
0x86, 0x68, 0x91, 0x52, 0x23, 0x64, 0x05, 0x54, 0x9d, 0x2c, 0x8a, 0xba, 0xb2, 0xc4, 0x9c, 0xcc,
0x14, 0xb0, 0x39, 0x10, 0x69, 0x25, 0x5f, 0x2e, 0x51, 0xf7, 0xd4, 0x92, 0xd0, 0xe2, 0xd4, 0x22,
0x47, 0x88, 0xb6, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x13, 0x2e, 0x7e, 0x14, 0x07,
0x67, 0xa6, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x3a, 0xf1, 0xbc, 0x38, 0x6e, 0xc8, 0xd8, 0x75,
0xc2, 0x90, 0xc5, 0xc6, 0xd6, 0xd4, 0x20, 0x88, 0xb7, 0x14, 0xa1, 0xd5, 0x33, 0xc5, 0x68, 0x16,
0x23, 0x97, 0x10, 0x92, 0x61, 0xc1, 0x10, 0x5f, 0x0a, 0x35, 0x33, 0x72, 0x31, 0xbb, 0xa7, 0x96,
0x08, 0x69, 0xe9, 0x61, 0xf1, 0xa8, 0x1e, 0x56, 0x07, 0x48, 0x29, 0x60, 0x55, 0x8b, 0xa4, 0x50,
0x49, 0xaf, 0xe9, 0xf2, 0x93, 0xc9, 0x4c, 0x1a, 0x42, 0x6a, 0xc8, 0xde, 0x87, 0x4a, 0x16, 0xeb,
0x57, 0xa3, 0x39, 0xbf, 0xd6, 0xc9, 0x36, 0xca, 0x3a, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f,
0x39, 0x3f, 0x57, 0x1f, 0x62, 0xba, 0x2e, 0x24, 0x5c, 0xd2, 0xf3, 0x75, 0xd3, 0x53, 0xf3, 0xc0,
0x41, 0xa2, 0x8f, 0x25, 0x60, 0xad, 0x33, 0x13, 0x73, 0x93, 0xd8, 0xc0, 0xd2, 0xc6, 0x80, 0x00,
0x00, 0x00, 0xff, 0xff, 0x80, 0x94, 0x59, 0x76, 0xdd, 0x01, 0x00, 0x00,
}

170
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/yandex_passport_user_account_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,170 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/yandex_passport_user_account_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetUserAccountByLoginRequest struct {
// Login of the YandexPassportUserAccount resource to return.
Login string `protobuf:"bytes,1,opt,name=login,proto3" json:"login,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetUserAccountByLoginRequest) Reset() { *m = GetUserAccountByLoginRequest{} }
func (m *GetUserAccountByLoginRequest) String() string { return proto.CompactTextString(m) }
func (*GetUserAccountByLoginRequest) ProtoMessage() {}
func (*GetUserAccountByLoginRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3, []int{0}
}
func (m *GetUserAccountByLoginRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserAccountByLoginRequest.Unmarshal(m, b)
}
func (m *GetUserAccountByLoginRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetUserAccountByLoginRequest.Marshal(b, m, deterministic)
}
func (dst *GetUserAccountByLoginRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetUserAccountByLoginRequest.Merge(dst, src)
}
func (m *GetUserAccountByLoginRequest) XXX_Size() int {
return xxx_messageInfo_GetUserAccountByLoginRequest.Size(m)
}
func (m *GetUserAccountByLoginRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetUserAccountByLoginRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetUserAccountByLoginRequest proto.InternalMessageInfo
func (m *GetUserAccountByLoginRequest) GetLogin() string {
if m != nil {
return m.Login
}
return ""
}
func init() {
proto.RegisterType((*GetUserAccountByLoginRequest)(nil), "yandex.cloud.iam.v1.GetUserAccountByLoginRequest")
}
// 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
// YandexPassportUserAccountServiceClient is the client API for YandexPassportUserAccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type YandexPassportUserAccountServiceClient interface {
// Returns the specified YandexPassportUserAccount resource.
GetByLogin(ctx context.Context, in *GetUserAccountByLoginRequest, opts ...grpc.CallOption) (*UserAccount, error)
}
type yandexPassportUserAccountServiceClient struct {
cc *grpc.ClientConn
}
func NewYandexPassportUserAccountServiceClient(cc *grpc.ClientConn) YandexPassportUserAccountServiceClient {
return &yandexPassportUserAccountServiceClient{cc}
}
func (c *yandexPassportUserAccountServiceClient) GetByLogin(ctx context.Context, in *GetUserAccountByLoginRequest, opts ...grpc.CallOption) (*UserAccount, error) {
out := new(UserAccount)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.YandexPassportUserAccountService/GetByLogin", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// YandexPassportUserAccountServiceServer is the server API for YandexPassportUserAccountService service.
type YandexPassportUserAccountServiceServer interface {
// Returns the specified YandexPassportUserAccount resource.
GetByLogin(context.Context, *GetUserAccountByLoginRequest) (*UserAccount, error)
}
func RegisterYandexPassportUserAccountServiceServer(s *grpc.Server, srv YandexPassportUserAccountServiceServer) {
s.RegisterService(&_YandexPassportUserAccountService_serviceDesc, srv)
}
func _YandexPassportUserAccountService_GetByLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserAccountByLoginRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(YandexPassportUserAccountServiceServer).GetByLogin(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.YandexPassportUserAccountService/GetByLogin",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(YandexPassportUserAccountServiceServer).GetByLogin(ctx, req.(*GetUserAccountByLoginRequest))
}
return interceptor(ctx, in, info, handler)
}
var _YandexPassportUserAccountService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.YandexPassportUserAccountService",
HandlerType: (*YandexPassportUserAccountServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetByLogin",
Handler: _YandexPassportUserAccountService_GetByLogin_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/yandex_passport_user_account_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/yandex_passport_user_account_service.proto", fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3)
}
var fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3 = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x87, 0x88, 0xc5, 0x17, 0x24, 0x16, 0x17, 0x17, 0xe4, 0x17, 0x95, 0xc4, 0x97, 0x16, 0xa7, 0x16,
0xc5, 0x27, 0x26, 0x27, 0xe7, 0x97, 0xe6, 0x95, 0xc4, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7,
0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x43, 0xd4, 0xea, 0x81, 0xf5, 0xeb, 0x65, 0x26,
0xe6, 0xea, 0x95, 0x19, 0x4a, 0xc9, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x27, 0x16, 0x64,
0xea, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0x15, 0x43, 0xb4, 0x48, 0xa9,
0x61, 0xb3, 0x12, 0xd9, 0x0a, 0xa8, 0x3a, 0x59, 0x14, 0x75, 0x65, 0x89, 0x39, 0x99, 0x29, 0x60,
0x73, 0x20, 0xd2, 0x4a, 0x56, 0x5c, 0x32, 0xee, 0xa9, 0x25, 0xa1, 0xc5, 0xa9, 0x45, 0x8e, 0x10,
0x6d, 0x4e, 0x95, 0x3e, 0xf9, 0xe9, 0x99, 0x79, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42,
0x52, 0x5c, 0xac, 0x39, 0x20, 0xbe, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xa7, 0x13, 0xcb, 0x8b, 0xe3,
0x86, 0x8c, 0x41, 0x10, 0x21, 0xa3, 0x5d, 0x8c, 0x5c, 0x0a, 0x91, 0x60, 0xd3, 0x03, 0xa0, 0x7e,
0x44, 0x32, 0x27, 0x18, 0xe2, 0x41, 0xa1, 0xa9, 0x8c, 0x5c, 0x5c, 0xee, 0xa9, 0x30, 0x63, 0x85,
0x0c, 0xf5, 0xb0, 0x78, 0x55, 0x0f, 0x9f, 0x13, 0xa4, 0x14, 0xb0, 0x6a, 0x41, 0x52, 0xaf, 0x64,
0xd4, 0x74, 0xf9, 0xc9, 0x64, 0x26, 0x1d, 0x21, 0x2d, 0xd4, 0xa0, 0xc7, 0xe2, 0xaa, 0x62, 0xab,
0x24, 0x88, 0xe1, 0x4e, 0xb6, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9,
0xb9, 0x50, 0x0d, 0xba, 0x90, 0x40, 0x4a, 0xcf, 0xd7, 0x4d, 0x4f, 0xcd, 0x03, 0x87, 0x8f, 0x3e,
0x96, 0x50, 0xb6, 0xce, 0x4c, 0xcc, 0x4d, 0x62, 0x03, 0x4b, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff,
0xff, 0xd5, 0x6e, 0x8b, 0x84, 0xfa, 0x01, 0x00, 0x00,
}

346
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1/health_check.pb.go generated vendored Normal file
View File

@ -0,0 +1,346 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/loadbalancer/v1/health_check.proto
package loadbalancer // import "github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import duration "github.com/golang/protobuf/ptypes/duration"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A HealthCheck resource. For more information, see [Health check](/docs/load-balancer/concepts/health-check).
type HealthCheck struct {
// Name of the health check. The name must be unique for each target group that attached to a single load balancer. 3-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// The interval between health checks. The default is 2 seconds.
Interval *duration.Duration `protobuf:"bytes,2,opt,name=interval,proto3" json:"interval,omitempty"`
// Timeout for a target to return a response for the health check. The default is 1 second.
Timeout *duration.Duration `protobuf:"bytes,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
// Number of failed health checks before changing the status to `` UNHEALTHY ``. The default is 2.
UnhealthyThreshold int64 `protobuf:"varint,4,opt,name=unhealthy_threshold,json=unhealthyThreshold,proto3" json:"unhealthy_threshold,omitempty"`
// Number of successful health checks required in order to set the `` HEALTHY `` status for the target. The default is 2.
HealthyThreshold int64 `protobuf:"varint,5,opt,name=healthy_threshold,json=healthyThreshold,proto3" json:"healthy_threshold,omitempty"`
// Protocol to use for the health check. Either TCP or HTTP.
//
// Types that are valid to be assigned to Options:
// *HealthCheck_TcpOptions_
// *HealthCheck_HttpOptions_
Options isHealthCheck_Options `protobuf_oneof:"options"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HealthCheck) Reset() { *m = HealthCheck{} }
func (m *HealthCheck) String() string { return proto.CompactTextString(m) }
func (*HealthCheck) ProtoMessage() {}
func (*HealthCheck) Descriptor() ([]byte, []int) {
return fileDescriptor_health_check_f79463e9bdeb651f, []int{0}
}
func (m *HealthCheck) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_HealthCheck.Unmarshal(m, b)
}
func (m *HealthCheck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_HealthCheck.Marshal(b, m, deterministic)
}
func (dst *HealthCheck) XXX_Merge(src proto.Message) {
xxx_messageInfo_HealthCheck.Merge(dst, src)
}
func (m *HealthCheck) XXX_Size() int {
return xxx_messageInfo_HealthCheck.Size(m)
}
func (m *HealthCheck) XXX_DiscardUnknown() {
xxx_messageInfo_HealthCheck.DiscardUnknown(m)
}
var xxx_messageInfo_HealthCheck proto.InternalMessageInfo
func (m *HealthCheck) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *HealthCheck) GetInterval() *duration.Duration {
if m != nil {
return m.Interval
}
return nil
}
func (m *HealthCheck) GetTimeout() *duration.Duration {
if m != nil {
return m.Timeout
}
return nil
}
func (m *HealthCheck) GetUnhealthyThreshold() int64 {
if m != nil {
return m.UnhealthyThreshold
}
return 0
}
func (m *HealthCheck) GetHealthyThreshold() int64 {
if m != nil {
return m.HealthyThreshold
}
return 0
}
type isHealthCheck_Options interface {
isHealthCheck_Options()
}
type HealthCheck_TcpOptions_ struct {
TcpOptions *HealthCheck_TcpOptions `protobuf:"bytes,6,opt,name=tcp_options,json=tcpOptions,proto3,oneof"`
}
type HealthCheck_HttpOptions_ struct {
HttpOptions *HealthCheck_HttpOptions `protobuf:"bytes,7,opt,name=http_options,json=httpOptions,proto3,oneof"`
}
func (*HealthCheck_TcpOptions_) isHealthCheck_Options() {}
func (*HealthCheck_HttpOptions_) isHealthCheck_Options() {}
func (m *HealthCheck) GetOptions() isHealthCheck_Options {
if m != nil {
return m.Options
}
return nil
}
func (m *HealthCheck) GetTcpOptions() *HealthCheck_TcpOptions {
if x, ok := m.GetOptions().(*HealthCheck_TcpOptions_); ok {
return x.TcpOptions
}
return nil
}
func (m *HealthCheck) GetHttpOptions() *HealthCheck_HttpOptions {
if x, ok := m.GetOptions().(*HealthCheck_HttpOptions_); ok {
return x.HttpOptions
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*HealthCheck) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _HealthCheck_OneofMarshaler, _HealthCheck_OneofUnmarshaler, _HealthCheck_OneofSizer, []interface{}{
(*HealthCheck_TcpOptions_)(nil),
(*HealthCheck_HttpOptions_)(nil),
}
}
func _HealthCheck_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*HealthCheck)
// options
switch x := m.Options.(type) {
case *HealthCheck_TcpOptions_:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.TcpOptions); err != nil {
return err
}
case *HealthCheck_HttpOptions_:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.HttpOptions); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("HealthCheck.Options has unexpected type %T", x)
}
return nil
}
func _HealthCheck_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*HealthCheck)
switch tag {
case 6: // options.tcp_options
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(HealthCheck_TcpOptions)
err := b.DecodeMessage(msg)
m.Options = &HealthCheck_TcpOptions_{msg}
return true, err
case 7: // options.http_options
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(HealthCheck_HttpOptions)
err := b.DecodeMessage(msg)
m.Options = &HealthCheck_HttpOptions_{msg}
return true, err
default:
return false, nil
}
}
func _HealthCheck_OneofSizer(msg proto.Message) (n int) {
m := msg.(*HealthCheck)
// options
switch x := m.Options.(type) {
case *HealthCheck_TcpOptions_:
s := proto.Size(x.TcpOptions)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *HealthCheck_HttpOptions_:
s := proto.Size(x.HttpOptions)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// Configuration option for a TCP health check.
type HealthCheck_TcpOptions struct {
// Port to use for TCP health checks.
Port int64 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HealthCheck_TcpOptions) Reset() { *m = HealthCheck_TcpOptions{} }
func (m *HealthCheck_TcpOptions) String() string { return proto.CompactTextString(m) }
func (*HealthCheck_TcpOptions) ProtoMessage() {}
func (*HealthCheck_TcpOptions) Descriptor() ([]byte, []int) {
return fileDescriptor_health_check_f79463e9bdeb651f, []int{0, 0}
}
func (m *HealthCheck_TcpOptions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_HealthCheck_TcpOptions.Unmarshal(m, b)
}
func (m *HealthCheck_TcpOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_HealthCheck_TcpOptions.Marshal(b, m, deterministic)
}
func (dst *HealthCheck_TcpOptions) XXX_Merge(src proto.Message) {
xxx_messageInfo_HealthCheck_TcpOptions.Merge(dst, src)
}
func (m *HealthCheck_TcpOptions) XXX_Size() int {
return xxx_messageInfo_HealthCheck_TcpOptions.Size(m)
}
func (m *HealthCheck_TcpOptions) XXX_DiscardUnknown() {
xxx_messageInfo_HealthCheck_TcpOptions.DiscardUnknown(m)
}
var xxx_messageInfo_HealthCheck_TcpOptions proto.InternalMessageInfo
func (m *HealthCheck_TcpOptions) GetPort() int64 {
if m != nil {
return m.Port
}
return 0
}
// Configuration option for an HTTP health check.
type HealthCheck_HttpOptions struct {
// Port to use for HTTP health checks.
Port int64 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
// URL path to set for health checking requests for every target in the target group.
// For example `` /ping ``. The default path is `` / ``.
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *HealthCheck_HttpOptions) Reset() { *m = HealthCheck_HttpOptions{} }
func (m *HealthCheck_HttpOptions) String() string { return proto.CompactTextString(m) }
func (*HealthCheck_HttpOptions) ProtoMessage() {}
func (*HealthCheck_HttpOptions) Descriptor() ([]byte, []int) {
return fileDescriptor_health_check_f79463e9bdeb651f, []int{0, 1}
}
func (m *HealthCheck_HttpOptions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_HealthCheck_HttpOptions.Unmarshal(m, b)
}
func (m *HealthCheck_HttpOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_HealthCheck_HttpOptions.Marshal(b, m, deterministic)
}
func (dst *HealthCheck_HttpOptions) XXX_Merge(src proto.Message) {
xxx_messageInfo_HealthCheck_HttpOptions.Merge(dst, src)
}
func (m *HealthCheck_HttpOptions) XXX_Size() int {
return xxx_messageInfo_HealthCheck_HttpOptions.Size(m)
}
func (m *HealthCheck_HttpOptions) XXX_DiscardUnknown() {
xxx_messageInfo_HealthCheck_HttpOptions.DiscardUnknown(m)
}
var xxx_messageInfo_HealthCheck_HttpOptions proto.InternalMessageInfo
func (m *HealthCheck_HttpOptions) GetPort() int64 {
if m != nil {
return m.Port
}
return 0
}
func (m *HealthCheck_HttpOptions) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func init() {
proto.RegisterType((*HealthCheck)(nil), "yandex.cloud.loadbalancer.v1.HealthCheck")
proto.RegisterType((*HealthCheck_TcpOptions)(nil), "yandex.cloud.loadbalancer.v1.HealthCheck.TcpOptions")
proto.RegisterType((*HealthCheck_HttpOptions)(nil), "yandex.cloud.loadbalancer.v1.HealthCheck.HttpOptions")
}
func init() {
proto.RegisterFile("yandex/cloud/loadbalancer/v1/health_check.proto", fileDescriptor_health_check_f79463e9bdeb651f)
}
var fileDescriptor_health_check_f79463e9bdeb651f = []byte{
// 441 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0x6e, 0xd3, 0x40,
0x10, 0xc6, 0x31, 0x31, 0x4d, 0x3b, 0x46, 0x02, 0x96, 0x8b, 0x89, 0x28, 0x04, 0x4e, 0x39, 0xb0,
0xeb, 0x6e, 0x42, 0x5a, 0x55, 0xdc, 0x0c, 0x87, 0x5c, 0x50, 0x25, 0xab, 0x12, 0x52, 0xa3, 0x2a,
0xda, 0xd8, 0x8b, 0xd7, 0x62, 0xe3, 0xb5, 0xdc, 0x71, 0x44, 0x0b, 0xbc, 0x1b, 0x9c, 0xf2, 0x10,
0xbc, 0x05, 0xc7, 0x9e, 0x50, 0xd7, 0xf9, 0x63, 0xa8, 0xd4, 0xf6, 0xe6, 0xd1, 0x7e, 0xbf, 0x6f,
0x3e, 0xef, 0xcc, 0x42, 0x70, 0x2e, 0xf2, 0x44, 0x7e, 0x0d, 0x62, 0x6d, 0xaa, 0x24, 0xd0, 0x46,
0x24, 0x53, 0xa1, 0x45, 0x1e, 0xcb, 0x32, 0x98, 0xf3, 0x40, 0x49, 0xa1, 0x51, 0x4d, 0x62, 0x25,
0xe3, 0x2f, 0xac, 0x28, 0x0d, 0x1a, 0xf2, 0xbc, 0x06, 0x98, 0x05, 0x58, 0x13, 0x60, 0x73, 0xde,
0x79, 0x91, 0x1a, 0x93, 0x6a, 0x19, 0x58, 0xed, 0xb4, 0xfa, 0x1c, 0x24, 0x55, 0x29, 0x30, 0x33,
0x79, 0x4d, 0x77, 0x76, 0xff, 0x69, 0x37, 0x17, 0x3a, 0x4b, 0x1a, 0xc7, 0xaf, 0x7f, 0xbb, 0xe0,
0x8d, 0x6c, 0xcf, 0xf7, 0x57, 0x2d, 0xc9, 0x10, 0xdc, 0x5c, 0xcc, 0xa4, 0xef, 0x74, 0x9d, 0xde,
0x4e, 0xf8, 0xea, 0xcf, 0x82, 0xef, 0x7e, 0x1f, 0x0b, 0x7a, 0x71, 0x3a, 0xa6, 0x82, 0x5e, 0xec,
0xd1, 0xc3, 0xd3, 0x6f, 0xfc, 0xcd, 0x3e, 0xff, 0x31, 0x5e, 0x56, 0x91, 0x95, 0x93, 0x21, 0x6c,
0x67, 0x39, 0xca, 0x72, 0x2e, 0xb4, 0x7f, 0xbf, 0xeb, 0xf4, 0xbc, 0xfe, 0x33, 0x56, 0x07, 0x63,
0xab, 0x60, 0xec, 0xc3, 0x32, 0x58, 0xb4, 0x96, 0x92, 0x01, 0xb4, 0x31, 0x9b, 0x49, 0x53, 0xa1,
0xdf, 0xba, 0x8d, 0x5a, 0x29, 0xc9, 0x21, 0x3c, 0xad, 0xf2, 0xfa, 0x9e, 0xce, 0x27, 0xa8, 0x4a,
0x79, 0xa6, 0x8c, 0x4e, 0x7c, 0xb7, 0xeb, 0xf4, 0x5a, 0xe1, 0xf6, 0xe5, 0x82, 0xbb, 0x7d, 0xca,
0xf7, 0x22, 0xb2, 0x16, 0x1d, 0xaf, 0x34, 0x64, 0x08, 0x4f, 0xae, 0x83, 0x0f, 0xfe, 0x03, 0x1f,
0x5f, 0xc3, 0x3e, 0x81, 0x87, 0x71, 0x31, 0x31, 0xc5, 0x55, 0x90, 0x33, 0x7f, 0xcb, 0x46, 0x7d,
0xcb, 0x6e, 0x9a, 0x0b, 0x6b, 0x5c, 0x2a, 0x3b, 0x8e, 0x8b, 0xa3, 0x9a, 0x1d, 0xdd, 0x8b, 0x00,
0xd7, 0x15, 0x39, 0x81, 0x87, 0x0a, 0x71, 0xe3, 0xdc, 0xb6, 0xce, 0xc3, 0xbb, 0x3b, 0x8f, 0x10,
0x1b, 0xd6, 0x9e, 0xda, 0x94, 0x1d, 0x0a, 0xb0, 0xe9, 0x4b, 0x5e, 0x82, 0x5b, 0x98, 0x12, 0xed,
0x5c, 0x5b, 0xa1, 0x77, 0xb9, 0xe0, 0x6d, 0x4e, 0x07, 0xfd, 0x83, 0xfd, 0x83, 0xc8, 0x1e, 0x74,
0x42, 0xf0, 0x1a, 0x66, 0xb7, 0xea, 0x09, 0x01, 0xb7, 0x10, 0xa8, 0xec, 0xb4, 0x77, 0x22, 0xfb,
0x1d, 0x3e, 0x82, 0xf6, 0xf2, 0x4f, 0x88, 0xfb, 0xf3, 0x17, 0x77, 0xc2, 0xa3, 0x93, 0x8f, 0x69,
0x86, 0xaa, 0x9a, 0xb2, 0xd8, 0xcc, 0x96, 0x8b, 0x4f, 0xeb, 0x4d, 0x4c, 0x0d, 0x4d, 0x65, 0x6e,
0xc7, 0x7c, 0xe3, 0x8b, 0x78, 0xd7, 0xac, 0xa7, 0x5b, 0x16, 0x18, 0xfc, 0x0d, 0x00, 0x00, 0xff,
0xff, 0xaf, 0x9c, 0x24, 0xf4, 0x45, 0x03, 0x00, 0x00,
}

615
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1/network_load_balancer.pb.go generated vendored Normal file
View File

@ -0,0 +1,615 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/loadbalancer/v1/network_load_balancer.proto
package loadbalancer // import "github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// IP version of the addresses that the load balancer works with.
// Only IPv4 is currently available.
type IpVersion int32
const (
IpVersion_IP_VERSION_UNSPECIFIED IpVersion = 0
// IPv4
IpVersion_IPV4 IpVersion = 1
// IPv6
IpVersion_IPV6 IpVersion = 2
)
var IpVersion_name = map[int32]string{
0: "IP_VERSION_UNSPECIFIED",
1: "IPV4",
2: "IPV6",
}
var IpVersion_value = map[string]int32{
"IP_VERSION_UNSPECIFIED": 0,
"IPV4": 1,
"IPV6": 2,
}
func (x IpVersion) String() string {
return proto.EnumName(IpVersion_name, int32(x))
}
func (IpVersion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{0}
}
type NetworkLoadBalancer_Status int32
const (
NetworkLoadBalancer_STATUS_UNSPECIFIED NetworkLoadBalancer_Status = 0
// Network load balancer is being created.
NetworkLoadBalancer_CREATING NetworkLoadBalancer_Status = 1
// Network load balancer is being started.
NetworkLoadBalancer_STARTING NetworkLoadBalancer_Status = 2
// Network load balancer is active and sends traffic to the targets.
NetworkLoadBalancer_ACTIVE NetworkLoadBalancer_Status = 3
// Network load balancer is being stopped.
NetworkLoadBalancer_STOPPING NetworkLoadBalancer_Status = 4
// Network load balancer is stopped and doesn't send traffic to the targets.
NetworkLoadBalancer_STOPPED NetworkLoadBalancer_Status = 5
// Network load balancer is being deleted.
NetworkLoadBalancer_DELETING NetworkLoadBalancer_Status = 6
// The load balancer doesn't have any listeners or target groups, or
// attached target groups are empty. The load balancer doesn't perform any health checks or
// send traffic in this state.
NetworkLoadBalancer_INACTIVE NetworkLoadBalancer_Status = 7
)
var NetworkLoadBalancer_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "STARTING",
3: "ACTIVE",
4: "STOPPING",
5: "STOPPED",
6: "DELETING",
7: "INACTIVE",
}
var NetworkLoadBalancer_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"STARTING": 2,
"ACTIVE": 3,
"STOPPING": 4,
"STOPPED": 5,
"DELETING": 6,
"INACTIVE": 7,
}
func (x NetworkLoadBalancer_Status) String() string {
return proto.EnumName(NetworkLoadBalancer_Status_name, int32(x))
}
func (NetworkLoadBalancer_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{0, 0}
}
// Type of the load balancer. Only external load balancers are currently available.
type NetworkLoadBalancer_Type int32
const (
NetworkLoadBalancer_TYPE_UNSPECIFIED NetworkLoadBalancer_Type = 0
// External network load balancer.
NetworkLoadBalancer_EXTERNAL NetworkLoadBalancer_Type = 1
)
var NetworkLoadBalancer_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "EXTERNAL",
}
var NetworkLoadBalancer_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"EXTERNAL": 1,
}
func (x NetworkLoadBalancer_Type) String() string {
return proto.EnumName(NetworkLoadBalancer_Type_name, int32(x))
}
func (NetworkLoadBalancer_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{0, 1}
}
// Type of session affinity. Only 5-tuple affinity is currently available.
// For more information, see [Load Balancer concepts](/load-balancer/concepts/).
type NetworkLoadBalancer_SessionAffinity int32
const (
NetworkLoadBalancer_SESSION_AFFINITY_UNSPECIFIED NetworkLoadBalancer_SessionAffinity = 0
// 5-tuple affinity.
NetworkLoadBalancer_CLIENT_IP_PORT_PROTO NetworkLoadBalancer_SessionAffinity = 1
)
var NetworkLoadBalancer_SessionAffinity_name = map[int32]string{
0: "SESSION_AFFINITY_UNSPECIFIED",
1: "CLIENT_IP_PORT_PROTO",
}
var NetworkLoadBalancer_SessionAffinity_value = map[string]int32{
"SESSION_AFFINITY_UNSPECIFIED": 0,
"CLIENT_IP_PORT_PROTO": 1,
}
func (x NetworkLoadBalancer_SessionAffinity) String() string {
return proto.EnumName(NetworkLoadBalancer_SessionAffinity_name, int32(x))
}
func (NetworkLoadBalancer_SessionAffinity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{0, 2}
}
// Network protocol to use.
type Listener_Protocol int32
const (
Listener_PROTOCOL_UNSPECIFIED Listener_Protocol = 0
Listener_TCP Listener_Protocol = 1
)
var Listener_Protocol_name = map[int32]string{
0: "PROTOCOL_UNSPECIFIED",
1: "TCP",
}
var Listener_Protocol_value = map[string]int32{
"PROTOCOL_UNSPECIFIED": 0,
"TCP": 1,
}
func (x Listener_Protocol) String() string {
return proto.EnumName(Listener_Protocol_name, int32(x))
}
func (Listener_Protocol) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{2, 0}
}
// Status of the target.
type TargetState_Status int32
const (
TargetState_STATUS_UNSPECIFIED TargetState_Status = 0
// The network load balancer is setting up health checks for this target.
TargetState_INITIAL TargetState_Status = 1
// Health check passed and the target is ready to receive traffic.
TargetState_HEALTHY TargetState_Status = 2
// Health check failed and the target is not receiving traffic.
TargetState_UNHEALTHY TargetState_Status = 3
// Target is being deleted and the network load balancer is no longer sending traffic to this target.
TargetState_DRAINING TargetState_Status = 4
// The network load balancer is stopped and not performing health checks on this target.
TargetState_INACTIVE TargetState_Status = 5
)
var TargetState_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "INITIAL",
2: "HEALTHY",
3: "UNHEALTHY",
4: "DRAINING",
5: "INACTIVE",
}
var TargetState_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"INITIAL": 1,
"HEALTHY": 2,
"UNHEALTHY": 3,
"DRAINING": 4,
"INACTIVE": 5,
}
func (x TargetState_Status) String() string {
return proto.EnumName(TargetState_Status_name, int32(x))
}
func (TargetState_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{3, 0}
}
// A NetworkLoadBalancer resource. For more information, see [Network Load Balancer](/docs/load-balancer/concepts).
type NetworkLoadBalancer struct {
// ID of the network load balancer.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the network load balancer belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the network load balancer. The name is unique within the folder. 3-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Optional description of the network load balancer. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Мaximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the region that the network load balancer belongs to.
RegionId string `protobuf:"bytes,7,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
// Status of the network load balancer.
Status NetworkLoadBalancer_Status `protobuf:"varint,9,opt,name=status,proto3,enum=yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_Status" json:"status,omitempty"`
// Type of the network load balancer. Only external network load balancers are available now.
Type NetworkLoadBalancer_Type `protobuf:"varint,10,opt,name=type,proto3,enum=yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_Type" json:"type,omitempty"`
// Type of the session affinity. Only 5-tuple affinity is available now.
SessionAffinity NetworkLoadBalancer_SessionAffinity `protobuf:"varint,11,opt,name=session_affinity,json=sessionAffinity,proto3,enum=yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_SessionAffinity" json:"session_affinity,omitempty"`
// List of listeners for the network load balancer.
Listeners []*Listener `protobuf:"bytes,12,rep,name=listeners,proto3" json:"listeners,omitempty"`
// List of target groups attached to the network load balancer.
AttachedTargetGroups []*AttachedTargetGroup `protobuf:"bytes,13,rep,name=attached_target_groups,json=attachedTargetGroups,proto3" json:"attached_target_groups,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NetworkLoadBalancer) Reset() { *m = NetworkLoadBalancer{} }
func (m *NetworkLoadBalancer) String() string { return proto.CompactTextString(m) }
func (*NetworkLoadBalancer) ProtoMessage() {}
func (*NetworkLoadBalancer) Descriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{0}
}
func (m *NetworkLoadBalancer) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NetworkLoadBalancer.Unmarshal(m, b)
}
func (m *NetworkLoadBalancer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NetworkLoadBalancer.Marshal(b, m, deterministic)
}
func (dst *NetworkLoadBalancer) XXX_Merge(src proto.Message) {
xxx_messageInfo_NetworkLoadBalancer.Merge(dst, src)
}
func (m *NetworkLoadBalancer) XXX_Size() int {
return xxx_messageInfo_NetworkLoadBalancer.Size(m)
}
func (m *NetworkLoadBalancer) XXX_DiscardUnknown() {
xxx_messageInfo_NetworkLoadBalancer.DiscardUnknown(m)
}
var xxx_messageInfo_NetworkLoadBalancer proto.InternalMessageInfo
func (m *NetworkLoadBalancer) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *NetworkLoadBalancer) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *NetworkLoadBalancer) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *NetworkLoadBalancer) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *NetworkLoadBalancer) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *NetworkLoadBalancer) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *NetworkLoadBalancer) GetRegionId() string {
if m != nil {
return m.RegionId
}
return ""
}
func (m *NetworkLoadBalancer) GetStatus() NetworkLoadBalancer_Status {
if m != nil {
return m.Status
}
return NetworkLoadBalancer_STATUS_UNSPECIFIED
}
func (m *NetworkLoadBalancer) GetType() NetworkLoadBalancer_Type {
if m != nil {
return m.Type
}
return NetworkLoadBalancer_TYPE_UNSPECIFIED
}
func (m *NetworkLoadBalancer) GetSessionAffinity() NetworkLoadBalancer_SessionAffinity {
if m != nil {
return m.SessionAffinity
}
return NetworkLoadBalancer_SESSION_AFFINITY_UNSPECIFIED
}
func (m *NetworkLoadBalancer) GetListeners() []*Listener {
if m != nil {
return m.Listeners
}
return nil
}
func (m *NetworkLoadBalancer) GetAttachedTargetGroups() []*AttachedTargetGroup {
if m != nil {
return m.AttachedTargetGroups
}
return nil
}
// An AttachedTargetGroup resource. For more information, see [Attached Target Groups](/load-balancer/concepts)
type AttachedTargetGroup struct {
// ID of the target group.
TargetGroupId string `protobuf:"bytes,1,opt,name=target_group_id,json=targetGroupId,proto3" json:"target_group_id,omitempty"`
// A health check to perform on the target group.
// For now we accept only one health check per AttachedTargetGroup.
HealthChecks []*HealthCheck `protobuf:"bytes,2,rep,name=health_checks,json=healthChecks,proto3" json:"health_checks,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AttachedTargetGroup) Reset() { *m = AttachedTargetGroup{} }
func (m *AttachedTargetGroup) String() string { return proto.CompactTextString(m) }
func (*AttachedTargetGroup) ProtoMessage() {}
func (*AttachedTargetGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{1}
}
func (m *AttachedTargetGroup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AttachedTargetGroup.Unmarshal(m, b)
}
func (m *AttachedTargetGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AttachedTargetGroup.Marshal(b, m, deterministic)
}
func (dst *AttachedTargetGroup) XXX_Merge(src proto.Message) {
xxx_messageInfo_AttachedTargetGroup.Merge(dst, src)
}
func (m *AttachedTargetGroup) XXX_Size() int {
return xxx_messageInfo_AttachedTargetGroup.Size(m)
}
func (m *AttachedTargetGroup) XXX_DiscardUnknown() {
xxx_messageInfo_AttachedTargetGroup.DiscardUnknown(m)
}
var xxx_messageInfo_AttachedTargetGroup proto.InternalMessageInfo
func (m *AttachedTargetGroup) GetTargetGroupId() string {
if m != nil {
return m.TargetGroupId
}
return ""
}
func (m *AttachedTargetGroup) GetHealthChecks() []*HealthCheck {
if m != nil {
return m.HealthChecks
}
return nil
}
// A Listener resource. For more information, see [Listener](/docs/load-balancer/concepts/listener)
type Listener struct {
// Name of the listener. The name must be unique for each listener on a single load balancer. 3-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// IP address for the listener.
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
// Port.
Port int64 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
// Network protocol for incoming traffic.
Protocol Listener_Protocol `protobuf:"varint,4,opt,name=protocol,proto3,enum=yandex.cloud.loadbalancer.v1.Listener_Protocol" json:"protocol,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Listener) Reset() { *m = Listener{} }
func (m *Listener) String() string { return proto.CompactTextString(m) }
func (*Listener) ProtoMessage() {}
func (*Listener) Descriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{2}
}
func (m *Listener) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Listener.Unmarshal(m, b)
}
func (m *Listener) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Listener.Marshal(b, m, deterministic)
}
func (dst *Listener) XXX_Merge(src proto.Message) {
xxx_messageInfo_Listener.Merge(dst, src)
}
func (m *Listener) XXX_Size() int {
return xxx_messageInfo_Listener.Size(m)
}
func (m *Listener) XXX_DiscardUnknown() {
xxx_messageInfo_Listener.DiscardUnknown(m)
}
var xxx_messageInfo_Listener proto.InternalMessageInfo
func (m *Listener) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Listener) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *Listener) GetPort() int64 {
if m != nil {
return m.Port
}
return 0
}
func (m *Listener) GetProtocol() Listener_Protocol {
if m != nil {
return m.Protocol
}
return Listener_PROTOCOL_UNSPECIFIED
}
// State of the target that was returned after the last health check.
type TargetState struct {
// ID of the subnet that the target is connected to.
SubnetId string `protobuf:"bytes,1,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// IP address of the target.
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
// Status of the target.
Status TargetState_Status `protobuf:"varint,3,opt,name=status,proto3,enum=yandex.cloud.loadbalancer.v1.TargetState_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TargetState) Reset() { *m = TargetState{} }
func (m *TargetState) String() string { return proto.CompactTextString(m) }
func (*TargetState) ProtoMessage() {}
func (*TargetState) Descriptor() ([]byte, []int) {
return fileDescriptor_network_load_balancer_8287c63ad9723666, []int{3}
}
func (m *TargetState) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TargetState.Unmarshal(m, b)
}
func (m *TargetState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TargetState.Marshal(b, m, deterministic)
}
func (dst *TargetState) XXX_Merge(src proto.Message) {
xxx_messageInfo_TargetState.Merge(dst, src)
}
func (m *TargetState) XXX_Size() int {
return xxx_messageInfo_TargetState.Size(m)
}
func (m *TargetState) XXX_DiscardUnknown() {
xxx_messageInfo_TargetState.DiscardUnknown(m)
}
var xxx_messageInfo_TargetState proto.InternalMessageInfo
func (m *TargetState) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *TargetState) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *TargetState) GetStatus() TargetState_Status {
if m != nil {
return m.Status
}
return TargetState_STATUS_UNSPECIFIED
}
func init() {
proto.RegisterType((*NetworkLoadBalancer)(nil), "yandex.cloud.loadbalancer.v1.NetworkLoadBalancer")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.loadbalancer.v1.NetworkLoadBalancer.LabelsEntry")
proto.RegisterType((*AttachedTargetGroup)(nil), "yandex.cloud.loadbalancer.v1.AttachedTargetGroup")
proto.RegisterType((*Listener)(nil), "yandex.cloud.loadbalancer.v1.Listener")
proto.RegisterType((*TargetState)(nil), "yandex.cloud.loadbalancer.v1.TargetState")
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.IpVersion", IpVersion_name, IpVersion_value)
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_Status", NetworkLoadBalancer_Status_name, NetworkLoadBalancer_Status_value)
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_Type", NetworkLoadBalancer_Type_name, NetworkLoadBalancer_Type_value)
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.NetworkLoadBalancer_SessionAffinity", NetworkLoadBalancer_SessionAffinity_name, NetworkLoadBalancer_SessionAffinity_value)
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.Listener_Protocol", Listener_Protocol_name, Listener_Protocol_value)
proto.RegisterEnum("yandex.cloud.loadbalancer.v1.TargetState_Status", TargetState_Status_name, TargetState_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/loadbalancer/v1/network_load_balancer.proto", fileDescriptor_network_load_balancer_8287c63ad9723666)
}
var fileDescriptor_network_load_balancer_8287c63ad9723666 = []byte{
// 977 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0x5f, 0x6f, 0xe3, 0x44,
0x10, 0xc7, 0x49, 0x9a, 0x3f, 0x93, 0xf6, 0x6a, 0xed, 0x55, 0x95, 0x55, 0xee, 0x44, 0xc8, 0x03,
0x2a, 0x27, 0xe2, 0xd4, 0xe5, 0xae, 0x6a, 0x39, 0xee, 0xc1, 0x4d, 0xdc, 0xab, 0x21, 0xe7, 0x58,
0x1b, 0xa7, 0xa2, 0x54, 0x27, 0x6b, 0x13, 0x6f, 0x13, 0xab, 0xae, 0x1d, 0xd9, 0x9b, 0x42, 0x0e,
0x10, 0x12, 0x8f, 0x7c, 0x03, 0x5e, 0xf9, 0x32, 0x77, 0x1f, 0x05, 0x89, 0x37, 0x24, 0xde, 0xd1,
0xae, 0x9d, 0x36, 0xed, 0x9d, 0x02, 0xc7, 0xdb, 0xce, 0xcc, 0xfe, 0x7e, 0xb3, 0xb3, 0xbf, 0xd9,
0x59, 0xd8, 0x9f, 0x91, 0xd0, 0xa3, 0xdf, 0x37, 0x87, 0x41, 0x34, 0xf5, 0x9a, 0x41, 0x44, 0xbc,
0x01, 0x09, 0x48, 0x38, 0xa4, 0x71, 0xf3, 0x4a, 0x6b, 0x86, 0x94, 0x7d, 0x17, 0xc5, 0x17, 0x2e,
0xf7, 0xbb, 0xf3, 0x80, 0x3a, 0x89, 0x23, 0x16, 0xa1, 0x07, 0x29, 0x52, 0x15, 0x48, 0x75, 0x11,
0xa9, 0x5e, 0x69, 0x5b, 0x1f, 0x8d, 0xa2, 0x68, 0x14, 0xd0, 0xa6, 0xd8, 0x3b, 0x98, 0x9e, 0x37,
0x99, 0x7f, 0x49, 0x13, 0x46, 0x2e, 0x27, 0x29, 0x7c, 0xeb, 0xe1, 0xad, 0xc4, 0x57, 0x24, 0xf0,
0x3d, 0xc2, 0xfc, 0x28, 0xcc, 0xc2, 0xcd, 0xa5, 0xe7, 0x1a, 0x53, 0x12, 0xb0, 0xb1, 0x3b, 0x1c,
0xd3, 0xe1, 0x45, 0x0a, 0xa8, 0xff, 0x56, 0x86, 0xfb, 0x56, 0x7a, 0xdc, 0x4e, 0x44, 0xbc, 0xc3,
0x6c, 0x37, 0xba, 0x07, 0x39, 0xdf, 0x53, 0xa4, 0x9a, 0xb4, 0x5d, 0xc1, 0x39, 0xdf, 0x43, 0x1f,
0x42, 0xe5, 0x3c, 0x0a, 0x3c, 0x1a, 0xbb, 0xbe, 0xa7, 0xe4, 0x84, 0xbb, 0x9c, 0x3a, 0x4c, 0x0f,
0x1d, 0x00, 0x0c, 0x63, 0x4a, 0x18, 0xf5, 0x5c, 0xc2, 0x94, 0x7c, 0x4d, 0xda, 0xae, 0xee, 0x6e,
0xa9, 0x69, 0x29, 0xea, 0xbc, 0x14, 0xd5, 0x99, 0x97, 0x82, 0x2b, 0xd9, 0x6e, 0x9d, 0x21, 0x04,
0x85, 0x90, 0x5c, 0x52, 0xa5, 0x20, 0x28, 0xc5, 0x1a, 0xd5, 0xa0, 0xea, 0xd1, 0x64, 0x18, 0xfb,
0x13, 0x5e, 0x99, 0xb2, 0x22, 0x42, 0x8b, 0x2e, 0xd4, 0x87, 0x62, 0x40, 0x06, 0x34, 0x48, 0x94,
0x62, 0x2d, 0xbf, 0x5d, 0xdd, 0x7d, 0xa6, 0x2e, 0xbb, 0x55, 0xf5, 0x1d, 0x05, 0xaa, 0x1d, 0x81,
0x37, 0x42, 0x16, 0xcf, 0x70, 0x46, 0xc6, 0x8b, 0x8c, 0xe9, 0xc8, 0x8f, 0x42, 0x5e, 0x64, 0x29,
0x2d, 0x32, 0x75, 0x98, 0x1e, 0xb2, 0xa1, 0x98, 0x30, 0xc2, 0xa6, 0x89, 0x52, 0xa9, 0x49, 0xdb,
0xf7, 0x76, 0xf7, 0xdf, 0x3f, 0x67, 0x4f, 0xe0, 0x71, 0xc6, 0x83, 0xbe, 0x82, 0x02, 0x9b, 0x4d,
0xa8, 0x02, 0x82, 0x6f, 0xef, 0xfd, 0xf9, 0x9c, 0xd9, 0x84, 0x62, 0xc1, 0x81, 0x02, 0x90, 0x13,
0x9a, 0x24, 0xfc, 0xec, 0xe4, 0xfc, 0xdc, 0x0f, 0x7d, 0x36, 0x53, 0xaa, 0x82, 0x57, 0xff, 0x1f,
0xe7, 0x4c, 0x99, 0xf4, 0x8c, 0x08, 0xaf, 0x27, 0xb7, 0x1d, 0xa8, 0x0d, 0x95, 0xc0, 0x4f, 0x18,
0x0d, 0x69, 0x9c, 0x28, 0xab, 0x42, 0x82, 0x4f, 0x96, 0xa7, 0xe9, 0x64, 0xdb, 0xf1, 0x0d, 0x10,
0x8d, 0x60, 0x93, 0x30, 0x46, 0x86, 0x63, 0xea, 0xb9, 0x8c, 0xc4, 0x23, 0xca, 0xdc, 0x51, 0x1c,
0x4d, 0x27, 0x89, 0xb2, 0x26, 0x28, 0xb5, 0xe5, 0x94, 0x7a, 0x86, 0x75, 0x04, 0xf4, 0x39, 0x47,
0xe2, 0x0d, 0xf2, 0xb6, 0x33, 0xd9, 0x3a, 0x80, 0xea, 0x82, 0xdc, 0x48, 0x86, 0xfc, 0x05, 0x9d,
0x65, 0xcd, 0xcd, 0x97, 0x68, 0x03, 0x56, 0xae, 0x48, 0x30, 0xa5, 0x59, 0x67, 0xa7, 0xc6, 0x17,
0xb9, 0x7d, 0xa9, 0xfe, 0x33, 0x14, 0x53, 0xd5, 0xd0, 0x26, 0xa0, 0x9e, 0xa3, 0x3b, 0xfd, 0x9e,
0xdb, 0xb7, 0x7a, 0xb6, 0xd1, 0x32, 0x8f, 0x4c, 0xa3, 0x2d, 0x7f, 0x80, 0x56, 0xa1, 0xdc, 0xc2,
0x86, 0xee, 0x98, 0xd6, 0x73, 0x59, 0xe2, 0x56, 0xcf, 0xd1, 0xb1, 0xb0, 0x72, 0x08, 0xa0, 0xa8,
0xb7, 0x1c, 0xf3, 0xc4, 0x90, 0xf3, 0x69, 0xa4, 0x6b, 0xdb, 0x3c, 0x52, 0x40, 0x55, 0x28, 0x09,
0xcb, 0x68, 0xcb, 0x2b, 0x3c, 0xd4, 0x36, 0x3a, 0x86, 0x00, 0x15, 0xb9, 0x65, 0x5a, 0x19, 0xac,
0x54, 0x7f, 0x04, 0x05, 0x2e, 0x33, 0xda, 0x00, 0xd9, 0x39, 0xb5, 0x8d, 0xb7, 0x93, 0x1b, 0xdf,
0x38, 0x06, 0xb6, 0xf4, 0x8e, 0x2c, 0xd5, 0x5f, 0xc0, 0xfa, 0x1d, 0xe9, 0x50, 0x0d, 0x1e, 0xf4,
0x8c, 0x5e, 0xcf, 0xec, 0x5a, 0xae, 0x7e, 0x74, 0x64, 0x5a, 0xa6, 0x73, 0x7a, 0x87, 0x42, 0x81,
0x8d, 0x56, 0xc7, 0x34, 0x2c, 0xc7, 0x35, 0x6d, 0xd7, 0xee, 0x62, 0xc7, 0xb5, 0x71, 0xd7, 0xe9,
0xca, 0x52, 0xfd, 0x77, 0x09, 0xee, 0xbf, 0xe3, 0x92, 0xd1, 0x63, 0x58, 0x5f, 0x94, 0xcb, 0x9d,
0x0f, 0x8a, 0xc3, 0xd5, 0x3f, 0x5e, 0x6b, 0xd2, 0xaf, 0x6f, 0xb4, 0xc2, 0x97, 0xcf, 0x9e, 0xec,
0xe0, 0x35, 0x76, 0x83, 0x31, 0x3d, 0xd4, 0x87, 0xb5, 0xc5, 0xf9, 0x93, 0x28, 0x39, 0x21, 0xf2,
0xa7, 0xcb, 0x45, 0x3e, 0x16, 0x90, 0x16, 0x47, 0x1c, 0xae, 0xfc, 0xf2, 0x46, 0x93, 0x34, 0xbc,
0x3a, 0xbe, 0xf1, 0x25, 0xf5, 0x3f, 0x25, 0x28, 0xcf, 0x9b, 0x0b, 0x3d, 0xc9, 0xa6, 0x49, 0x7a,
0x9c, 0x8f, 0xff, 0x7a, 0xad, 0x3d, 0xfc, 0xf1, 0x8c, 0x34, 0x5e, 0xbd, 0x3c, 0x6b, 0x90, 0xc6,
0xab, 0x9d, 0xc6, 0xc1, 0xcb, 0x1f, 0xb4, 0xcf, 0xf6, 0xb4, 0x9f, 0xce, 0x32, 0x2b, 0x1b, 0x38,
0x0a, 0x94, 0x88, 0xe7, 0xc5, 0x34, 0x49, 0xb2, 0x06, 0x98, 0x9b, 0x7c, 0x3c, 0x4d, 0xa2, 0x38,
0x9d, 0x69, 0x79, 0x2c, 0xd6, 0xe8, 0x6b, 0x28, 0x8b, 0x99, 0x36, 0x8c, 0x02, 0x31, 0xb6, 0xee,
0xed, 0x36, 0xff, 0x5b, 0xef, 0xab, 0x76, 0x06, 0xc3, 0xd7, 0x04, 0xf5, 0x06, 0x94, 0xe7, 0x5e,
0xae, 0x84, 0xb8, 0xfa, 0x56, 0xb7, 0x73, 0x47, 0xa3, 0x12, 0xe4, 0x9d, 0x96, 0x2d, 0x4b, 0xf5,
0xbf, 0x25, 0xa8, 0xa6, 0x52, 0xf0, 0xae, 0xa4, 0x7c, 0x62, 0x25, 0xd3, 0x41, 0x48, 0xd9, 0xb5,
0x08, 0xb8, 0x9c, 0x3a, 0x4c, 0x6f, 0x49, 0x59, 0xc7, 0xd7, 0xb3, 0x2c, 0x2f, 0x0a, 0xd8, 0x59,
0x5e, 0xc0, 0x42, 0xc6, 0x3b, 0x33, 0xac, 0x4e, 0xff, 0xf5, 0x7d, 0x54, 0xa1, 0xc4, 0xdb, 0xce,
0xe4, 0x1d, 0xca, 0x8d, 0x63, 0x43, 0xef, 0x38, 0xc7, 0xa7, 0x72, 0x0e, 0xad, 0x41, 0xa5, 0x6f,
0xcd, 0x4d, 0xf1, 0x40, 0xda, 0x58, 0x37, 0xad, 0xf4, 0x81, 0x2c, 0xbe, 0x82, 0x95, 0x47, 0x4f,
0xa1, 0x62, 0x4e, 0x4e, 0x68, 0xcc, 0x7b, 0x1b, 0x6d, 0xc1, 0xa6, 0x69, 0xbb, 0x27, 0x06, 0x16,
0x6d, 0x7d, 0x3b, 0x5b, 0x19, 0x0a, 0xa6, 0x7d, 0xf2, 0x58, 0x96, 0xb2, 0xd5, 0x9e, 0x9c, 0x3b,
0xec, 0x7e, 0xfb, 0x62, 0xe4, 0xb3, 0xf1, 0x74, 0xa0, 0x0e, 0xa3, 0xcb, 0xec, 0x87, 0x6c, 0xa4,
0x3f, 0xe4, 0x28, 0x6a, 0x8c, 0x68, 0x28, 0xd4, 0x58, 0xfa, 0x75, 0x3e, 0x5d, 0xb4, 0x07, 0x45,
0x01, 0xf8, 0xfc, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x8d, 0xac, 0xdb, 0x06, 0x08, 0x00,
0x00,
}

2158
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1/network_load_balancer_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

215
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1/target_group.pb.go generated vendored Normal file
View File

@ -0,0 +1,215 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/loadbalancer/v1/target_group.proto
package loadbalancer // import "github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A TargetGroup resource. For more information, see [Target groups and resources](/docs/load-balancer/target-resources).
type TargetGroup struct {
// Output only. ID of the target group.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the target group belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Output only. Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the target group.
// The name is unique within the folder. 3-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the target group. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Мaximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the region where the target group resides.
RegionId string `protobuf:"bytes,7,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
// A list of targets in the target group.
Targets []*Target `protobuf:"bytes,9,rep,name=targets,proto3" json:"targets,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TargetGroup) Reset() { *m = TargetGroup{} }
func (m *TargetGroup) String() string { return proto.CompactTextString(m) }
func (*TargetGroup) ProtoMessage() {}
func (*TargetGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_target_group_035afd173b2a7108, []int{0}
}
func (m *TargetGroup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TargetGroup.Unmarshal(m, b)
}
func (m *TargetGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TargetGroup.Marshal(b, m, deterministic)
}
func (dst *TargetGroup) XXX_Merge(src proto.Message) {
xxx_messageInfo_TargetGroup.Merge(dst, src)
}
func (m *TargetGroup) XXX_Size() int {
return xxx_messageInfo_TargetGroup.Size(m)
}
func (m *TargetGroup) XXX_DiscardUnknown() {
xxx_messageInfo_TargetGroup.DiscardUnknown(m)
}
var xxx_messageInfo_TargetGroup proto.InternalMessageInfo
func (m *TargetGroup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *TargetGroup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *TargetGroup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *TargetGroup) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *TargetGroup) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *TargetGroup) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *TargetGroup) GetRegionId() string {
if m != nil {
return m.RegionId
}
return ""
}
func (m *TargetGroup) GetTargets() []*Target {
if m != nil {
return m.Targets
}
return nil
}
// A Target resource. For more information, see [Target groups and resources](/docs/load-balancer/target-resources).
type Target struct {
// ID of the subnet that targets are connected to.
// All targets in the target group must be connected to the same subnet within a single availability zone.
SubnetId string `protobuf:"bytes,1,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// IP address of the target.
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Target) Reset() { *m = Target{} }
func (m *Target) String() string { return proto.CompactTextString(m) }
func (*Target) ProtoMessage() {}
func (*Target) Descriptor() ([]byte, []int) {
return fileDescriptor_target_group_035afd173b2a7108, []int{1}
}
func (m *Target) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Target.Unmarshal(m, b)
}
func (m *Target) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Target.Marshal(b, m, deterministic)
}
func (dst *Target) XXX_Merge(src proto.Message) {
xxx_messageInfo_Target.Merge(dst, src)
}
func (m *Target) XXX_Size() int {
return xxx_messageInfo_Target.Size(m)
}
func (m *Target) XXX_DiscardUnknown() {
xxx_messageInfo_Target.DiscardUnknown(m)
}
var xxx_messageInfo_Target proto.InternalMessageInfo
func (m *Target) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *Target) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func init() {
proto.RegisterType((*TargetGroup)(nil), "yandex.cloud.loadbalancer.v1.TargetGroup")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.loadbalancer.v1.TargetGroup.LabelsEntry")
proto.RegisterType((*Target)(nil), "yandex.cloud.loadbalancer.v1.Target")
}
func init() {
proto.RegisterFile("yandex/cloud/loadbalancer/v1/target_group.proto", fileDescriptor_target_group_035afd173b2a7108)
}
var fileDescriptor_target_group_035afd173b2a7108 = []byte{
// 415 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x4d, 0x8b, 0x14, 0x31,
0x10, 0x65, 0x3e, 0x76, 0x66, 0xba, 0x1a, 0x44, 0x82, 0x87, 0x30, 0x2a, 0x0e, 0x8b, 0xc2, 0x5c,
0x36, 0xed, 0xac, 0x2c, 0xb8, 0x7e, 0x81, 0x0b, 0x22, 0x03, 0x2e, 0x42, 0xb3, 0x27, 0x2f, 0x43,
0xba, 0x53, 0x1b, 0x83, 0x99, 0x64, 0x48, 0xa7, 0x1b, 0xe7, 0x2f, 0x78, 0xf4, 0x57, 0xf9, 0xb3,
0xa4, 0x93, 0x6e, 0x68, 0x2f, 0x83, 0xb7, 0x54, 0x55, 0x5e, 0xbd, 0xf7, 0xaa, 0x0a, 0xb2, 0x23,
0x37, 0x02, 0x7f, 0x66, 0xa5, 0xb6, 0xb5, 0xc8, 0xb4, 0xe5, 0xa2, 0xe0, 0x9a, 0x9b, 0x12, 0x5d,
0xd6, 0x6c, 0x32, 0xcf, 0x9d, 0x44, 0xbf, 0x93, 0xce, 0xd6, 0x07, 0x76, 0x70, 0xd6, 0x5b, 0xf2,
0x24, 0x02, 0x58, 0x00, 0xb0, 0x21, 0x80, 0x35, 0x9b, 0xe5, 0x33, 0x69, 0xad, 0xd4, 0x98, 0x85,
0xbf, 0x45, 0x7d, 0x9f, 0x79, 0xb5, 0xc7, 0xca, 0xf3, 0x7d, 0x07, 0x5f, 0x3e, 0xfd, 0x87, 0xaf,
0xe1, 0x5a, 0x09, 0xee, 0x95, 0x35, 0xb1, 0x7c, 0xfe, 0x7b, 0x02, 0xe9, 0x5d, 0x20, 0xfd, 0xdc,
0x72, 0x92, 0x07, 0x30, 0x56, 0x82, 0x8e, 0x56, 0xa3, 0x75, 0x92, 0x8f, 0x95, 0x20, 0x8f, 0x21,
0xb9, 0xb7, 0x5a, 0xa0, 0xdb, 0x29, 0x41, 0xc7, 0x21, 0xbd, 0x88, 0x89, 0xad, 0x20, 0xd7, 0x00,
0xa5, 0x43, 0xee, 0x51, 0xec, 0xb8, 0xa7, 0x93, 0xd5, 0x68, 0x9d, 0x5e, 0x2e, 0x59, 0x54, 0xc4,
0x7a, 0x45, 0xec, 0xae, 0x57, 0x94, 0x27, 0xdd, 0xef, 0x8f, 0x9e, 0x10, 0x98, 0x1a, 0xbe, 0x47,
0x3a, 0x0d, 0x2d, 0xc3, 0x9b, 0xac, 0x20, 0x15, 0x58, 0x95, 0x4e, 0x1d, 0x5a, 0x81, 0xf4, 0x2c,
0x94, 0x86, 0x29, 0x72, 0x0b, 0x33, 0xcd, 0x0b, 0xd4, 0x15, 0x9d, 0xad, 0x26, 0xeb, 0xf4, 0xf2,
0x8a, 0x9d, 0x1a, 0x0e, 0x1b, 0x18, 0x63, 0x5f, 0x02, 0xee, 0x93, 0xf1, 0xee, 0x98, 0x77, 0x4d,
0x5a, 0x73, 0x0e, 0xa5, 0xb2, 0xa6, 0x35, 0x37, 0x8f, 0xe6, 0x62, 0x62, 0x2b, 0xc8, 0x07, 0x98,
0xc7, 0x6d, 0x54, 0x34, 0x09, 0x64, 0xcf, 0xff, 0x87, 0x2c, 0xef, 0x41, 0xcb, 0x6b, 0x48, 0x07,
0x9c, 0xe4, 0x21, 0x4c, 0x7e, 0xe0, 0xb1, 0x9b, 0x6c, 0xfb, 0x24, 0x8f, 0xe0, 0xac, 0xe1, 0xba,
0xc6, 0x6e, 0xac, 0x31, 0x78, 0x33, 0x7e, 0x3d, 0x3a, 0xdf, 0xc2, 0x2c, 0x76, 0x23, 0x2f, 0x20,
0xa9, 0xea, 0xc2, 0xa0, 0xdf, 0xf5, 0x5b, 0xb9, 0x59, 0xfc, 0xfa, 0xb3, 0x99, 0xbe, 0x7b, 0x7f,
0xf5, 0x32, 0x5f, 0xc4, 0xd2, 0x56, 0x10, 0x0a, 0x73, 0x2e, 0x84, 0xc3, 0xaa, 0xea, 0x9a, 0xf5,
0xe1, 0xcd, 0xd7, 0x6f, 0xb7, 0x52, 0xf9, 0xef, 0x75, 0xc1, 0x4a, 0xbb, 0xef, 0x6e, 0xef, 0x22,
0xde, 0x82, 0xb4, 0x17, 0x12, 0x4d, 0x58, 0xd3, 0xc9, 0xa3, 0x7c, 0x3b, 0x8c, 0x8b, 0x59, 0x00,
0xbc, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x82, 0x5e, 0x67, 0x5c, 0xc8, 0x02, 0x00, 0x00,
}

1238
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1/target_group_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

137
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,137 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/backup.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse Backup resource. See the [Developer's Guide](/docs/managed-clickhouse/concepts)
// for more information.
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the ClickHouse cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
SourceShardNames []string `protobuf:"bytes,6,rep,name=source_shard_names,json=sourceShardNames,proto3" json:"source_shard_names,omitempty"`
// Time when the backup operation was started.
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_63c80d0c65f0a55c, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetSourceShardNames() []string {
if m != nil {
return m.SourceShardNames
}
return nil
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.clickhouse.v1.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/backup.proto", fileDescriptor_backup_63c80d0c65f0a55c)
}
var fileDescriptor_backup_63c80d0c65f0a55c = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xcd, 0x4e, 0x02, 0x31,
0x14, 0x85, 0xc3, 0xa0, 0xc4, 0xa9, 0x89, 0x3f, 0x5d, 0x4d, 0x30, 0x51, 0xe2, 0x8a, 0xa8, 0xb4,
0x41, 0x57, 0xc6, 0x15, 0xb8, 0x62, 0xa1, 0x26, 0xe8, 0xca, 0xcd, 0xa4, 0xed, 0x2d, 0x43, 0xc3,
0x94, 0x92, 0xfe, 0x10, 0x7d, 0x00, 0xdf, 0xdb, 0x4c, 0x3b, 0x84, 0x9d, 0x2e, 0x7b, 0xee, 0x77,
0xcf, 0x39, 0xe9, 0x45, 0xb7, 0xdf, 0x6c, 0x0d, 0xf2, 0x8b, 0x8a, 0xda, 0x04, 0xa0, 0x1a, 0x38,
0x15, 0xb5, 0x12, 0xab, 0xa5, 0x09, 0x4e, 0xd2, 0xed, 0x98, 0x72, 0x26, 0x56, 0x61, 0x43, 0x36,
0xd6, 0x78, 0x83, 0x2f, 0x13, 0x4c, 0x22, 0x4c, 0x34, 0x70, 0xb2, 0x87, 0xc9, 0x76, 0xdc, 0xbf,
0xaa, 0x8c, 0xa9, 0x6a, 0x49, 0x23, 0xcd, 0xc3, 0x82, 0x7a, 0xa5, 0xa5, 0xf3, 0x4c, 0xb7, 0x06,
0xd7, 0x3f, 0x19, 0xea, 0x4d, 0xa3, 0x23, 0x3e, 0x41, 0x99, 0x82, 0xa2, 0x33, 0xe8, 0x0c, 0xf3,
0x79, 0xa6, 0x00, 0x5f, 0xa0, 0x7c, 0x61, 0x6a, 0x90, 0xb6, 0x54, 0x50, 0x64, 0x51, 0x3e, 0x4a,
0xc2, 0x0c, 0xf0, 0x23, 0x42, 0xc2, 0x4a, 0xe6, 0x25, 0x94, 0xcc, 0x17, 0xdd, 0x41, 0x67, 0x78,
0x7c, 0xdf, 0x27, 0x29, 0x8d, 0xec, 0xd2, 0xc8, 0xc7, 0x2e, 0x6d, 0x9e, 0xb7, 0xf4, 0xc4, 0xe3,
0x1b, 0x74, 0xee, 0x4c, 0xb0, 0x42, 0x96, 0xa2, 0x0e, 0xce, 0x27, 0xff, 0x83, 0xe8, 0x7f, 0x9a,
0x06, 0xcf, 0x49, 0x9f, 0x01, 0xbe, 0x43, 0xb8, 0x65, 0xdd, 0x92, 0x59, 0x28, 0xd7, 0x4c, 0x4b,
0x57, 0xf4, 0x06, 0xdd, 0x61, 0x3e, 0x3f, 0x4b, 0x93, 0xf7, 0x66, 0xf0, 0xda, 0xe8, 0x4d, 0x29,
0xe7, 0x99, 0x6d, 0x4b, 0x1d, 0xfe, 0x5f, 0xaa, 0xa5, 0x27, 0x7e, 0xfa, 0xf6, 0xf9, 0x52, 0x29,
0xbf, 0x0c, 0x9c, 0x08, 0xa3, 0x69, 0xfa, 0xd5, 0x51, 0x3a, 0x41, 0x65, 0x46, 0x95, 0x5c, 0xc7,
0x75, 0xfa, 0xf7, 0x6d, 0x9e, 0xf6, 0x2f, 0xde, 0x8b, 0x0b, 0x0f, 0xbf, 0x01, 0x00, 0x00, 0xff,
0xff, 0xcc, 0x05, 0xcb, 0xe2, 0xcf, 0x01, 0x00, 0x00,
}

335
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,335 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/backup_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the backup to return information about.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListBackupsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the [ListBackupsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// List of Backup resources.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListBackupsResponse")
}
// 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
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified ClickHouse Backup resource.
//
// To get the list of available ClickHouse Backup resources, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified ClickHouse Backup resource.
//
// To get the list of available ClickHouse Backup resources, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/backup_service.proto", fileDescriptor_backup_service_c0389392897d6e8b)
}
var fileDescriptor_backup_service_c0389392897d6e8b = []byte{
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x3f, 0x6f, 0xd3, 0x40,
0x14, 0xc0, 0xe5, 0x24, 0x94, 0xf8, 0xa0, 0x02, 0x1d, 0x4b, 0x14, 0x41, 0x15, 0x3c, 0x84, 0xf0,
0x27, 0x3e, 0x3b, 0x51, 0x27, 0x5a, 0x09, 0x65, 0xa9, 0x2a, 0x81, 0x40, 0x2e, 0x13, 0x4b, 0x74,
0xf6, 0x3d, 0xdc, 0x53, 0x9c, 0x3b, 0x93, 0x3b, 0x47, 0xa5, 0x08, 0x21, 0x31, 0x76, 0xa4, 0x03,
0x1f, 0x87, 0xb1, 0xdd, 0xf9, 0x0a, 0x0c, 0x7c, 0x06, 0x26, 0xe4, 0x3b, 0x87, 0x50, 0x40, 0x69,
0x18, 0x7d, 0xef, 0xfd, 0xde, 0xfb, 0xe9, 0xbd, 0x67, 0x34, 0x7c, 0x4b, 0x05, 0x83, 0x23, 0x92,
0x64, 0xb2, 0x60, 0x64, 0xca, 0x62, 0x92, 0x64, 0x3c, 0x99, 0x1c, 0xca, 0x42, 0x01, 0x99, 0x87,
0x24, 0xa6, 0xc9, 0xa4, 0xc8, 0xc7, 0x0a, 0x66, 0x73, 0x9e, 0x80, 0x9f, 0xcf, 0xa4, 0x96, 0x78,
0xcb, 0x42, 0xbe, 0x81, 0xfc, 0x29, 0x8b, 0xfd, 0x25, 0xe4, 0xcf, 0xc3, 0xf6, 0xed, 0x54, 0xca,
0x34, 0x03, 0x42, 0x73, 0x4e, 0xa8, 0x10, 0x52, 0x53, 0xcd, 0xa5, 0x50, 0x96, 0x6e, 0x3f, 0x5c,
0xab, 0x65, 0x95, 0x7c, 0xe7, 0x42, 0xf2, 0x9c, 0x66, 0x9c, 0x99, 0x62, 0x36, 0xec, 0x6d, 0xa3,
0x9b, 0x7b, 0xa0, 0x47, 0x86, 0x88, 0xe0, 0x4d, 0x01, 0x4a, 0xe3, 0xbb, 0xc8, 0xad, 0xac, 0x39,
0x6b, 0x39, 0x1d, 0xa7, 0xe7, 0x8e, 0x1a, 0xdf, 0xcf, 0x42, 0x27, 0x6a, 0xda, 0xe7, 0x7d, 0xe6,
0x7d, 0x72, 0x10, 0x7e, 0xca, 0x55, 0x05, 0xaa, 0x05, 0x79, 0x1f, 0xb9, 0xaf, 0x65, 0xc6, 0x60,
0xb6, 0x24, 0xaf, 0x97, 0xe4, 0xc9, 0x79, 0xd8, 0xd8, 0xd9, 0xdd, 0x0e, 0xa2, 0xa6, 0x0d, 0xef,
0x33, 0x7c, 0x0f, 0xb9, 0x39, 0x4d, 0x61, 0xac, 0xf8, 0x31, 0xb4, 0x6a, 0x1d, 0xa7, 0x57, 0x1f,
0xa1, 0x1f, 0x67, 0xe1, 0xc6, 0xce, 0x6e, 0x18, 0x04, 0x41, 0xd4, 0x2c, 0x83, 0x07, 0xfc, 0x18,
0x70, 0x0f, 0x21, 0x93, 0xa8, 0xe5, 0x04, 0x44, 0xab, 0x6e, 0x8a, 0xba, 0x27, 0xe7, 0xe1, 0x15,
0x93, 0x19, 0x99, 0x2a, 0x2f, 0xcb, 0x98, 0xf7, 0x01, 0xdd, 0xba, 0xe0, 0xa4, 0x72, 0x29, 0x14,
0xe0, 0x27, 0xe8, 0xaa, 0xf5, 0x56, 0x2d, 0xa7, 0x53, 0xef, 0x5d, 0x1b, 0x74, 0xfd, 0xd5, 0xe3,
0xf7, 0xab, 0x71, 0x2c, 0x30, 0xdc, 0x45, 0x37, 0x04, 0x1c, 0xe9, 0xf1, 0x6f, 0x1e, 0xa5, 0xb1,
0x1b, 0x6d, 0x96, 0xcf, 0x2f, 0x16, 0x02, 0x83, 0x2f, 0x35, 0xb4, 0x69, 0xd9, 0x03, 0xbb, 0x6e,
0x7c, 0xea, 0xa0, 0xfa, 0x1e, 0x68, 0x1c, 0x5c, 0xd6, 0xf2, 0xcf, 0x25, 0xb4, 0xd7, 0x94, 0xf4,
0x06, 0x1f, 0xbf, 0x7e, 0x3b, 0xad, 0x3d, 0xc2, 0x0f, 0xc8, 0x94, 0x0a, 0x9a, 0x02, 0xeb, 0xff,
0xeb, 0x18, 0x14, 0x79, 0xf7, 0x6b, 0xa5, 0xef, 0xf1, 0x67, 0x07, 0x35, 0xca, 0x49, 0xe1, 0xc1,
0x65, 0x4d, 0xfe, 0xde, 0x71, 0x7b, 0xf8, 0x5f, 0x8c, 0xdd, 0x81, 0xd7, 0x35, 0x96, 0x1d, 0xbc,
0xb5, 0xda, 0x72, 0xf4, 0xfc, 0xd5, 0xb3, 0x94, 0xeb, 0xc3, 0x22, 0xf6, 0x13, 0x39, 0x25, 0xb6,
0x51, 0xdf, 0x9e, 0x6e, 0x2a, 0xfb, 0x29, 0x08, 0x73, 0xb5, 0x64, 0xf5, 0x0f, 0xf0, 0x78, 0xf9,
0x15, 0x6f, 0x18, 0x60, 0xf8, 0x33, 0x00, 0x00, 0xff, 0xff, 0xda, 0x84, 0x09, 0x05, 0xa7, 0x03,
0x00, 0x00,
}

1092
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/cluster.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

3607
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1889
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config/clickhouse.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

137
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/database.pb.go generated vendored Normal file
View File

@ -0,0 +1,137 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/database.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse Database resource. For more information, see the
// [Developer's Guide](/docs/managed-clickhouse/concepts).
type Database struct {
// Name of the database.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the ClickHouse cluster that the database belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Database) Reset() { *m = Database{} }
func (m *Database) String() string { return proto.CompactTextString(m) }
func (*Database) ProtoMessage() {}
func (*Database) Descriptor() ([]byte, []int) {
return fileDescriptor_database_d83bcea5c6482814, []int{0}
}
func (m *Database) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Database.Unmarshal(m, b)
}
func (m *Database) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Database.Marshal(b, m, deterministic)
}
func (dst *Database) XXX_Merge(src proto.Message) {
xxx_messageInfo_Database.Merge(dst, src)
}
func (m *Database) XXX_Size() int {
return xxx_messageInfo_Database.Size(m)
}
func (m *Database) XXX_DiscardUnknown() {
xxx_messageInfo_Database.DiscardUnknown(m)
}
var xxx_messageInfo_Database proto.InternalMessageInfo
func (m *Database) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Database) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
type DatabaseSpec struct {
// Name of the ClickHouse database. 1-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DatabaseSpec) Reset() { *m = DatabaseSpec{} }
func (m *DatabaseSpec) String() string { return proto.CompactTextString(m) }
func (*DatabaseSpec) ProtoMessage() {}
func (*DatabaseSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_database_d83bcea5c6482814, []int{1}
}
func (m *DatabaseSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DatabaseSpec.Unmarshal(m, b)
}
func (m *DatabaseSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DatabaseSpec.Marshal(b, m, deterministic)
}
func (dst *DatabaseSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_DatabaseSpec.Merge(dst, src)
}
func (m *DatabaseSpec) XXX_Size() int {
return xxx_messageInfo_DatabaseSpec.Size(m)
}
func (m *DatabaseSpec) XXX_DiscardUnknown() {
xxx_messageInfo_DatabaseSpec.DiscardUnknown(m)
}
var xxx_messageInfo_DatabaseSpec proto.InternalMessageInfo
func (m *DatabaseSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*Database)(nil), "yandex.cloud.mdb.clickhouse.v1.Database")
proto.RegisterType((*DatabaseSpec)(nil), "yandex.cloud.mdb.clickhouse.v1.DatabaseSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/database.proto", fileDescriptor_database_d83bcea5c6482814)
}
var fileDescriptor_database_d83bcea5c6482814 = []byte{
// 240 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xad, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0x4f, 0xce, 0xc9,
0x4c, 0xce, 0xce, 0xc8, 0x2f, 0x2d, 0x4e, 0xd5, 0x2f, 0x33, 0xd4, 0x4f, 0x49, 0x2c, 0x49, 0x4c,
0x4a, 0x2c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x83, 0x28, 0xd7, 0x03, 0x2b,
0xd7, 0xcb, 0x4d, 0x49, 0xd2, 0x43, 0x28, 0xd7, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xae, 0x2c,
0x31, 0x27, 0x33, 0x25, 0xb1, 0x24, 0x33, 0x3f, 0x0f, 0xa2, 0x5d, 0xc9, 0x96, 0x8b, 0xc3, 0x05,
0x6a, 0xa0, 0x90, 0x10, 0x17, 0x4b, 0x5e, 0x62, 0x6e, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67,
0x10, 0x98, 0x2d, 0x24, 0xcb, 0xc5, 0x95, 0x9c, 0x53, 0x5a, 0x5c, 0x92, 0x5a, 0x14, 0x9f, 0x99,
0x22, 0xc1, 0x04, 0x96, 0xe1, 0x84, 0x8a, 0x78, 0xa6, 0x28, 0x39, 0x71, 0xf1, 0xc0, 0xb4, 0x07,
0x17, 0xa4, 0x26, 0x0b, 0x19, 0x21, 0x1b, 0xe1, 0x24, 0xf7, 0xe2, 0xb8, 0x21, 0xe3, 0xa7, 0xe3,
0x86, 0x7c, 0xd1, 0x89, 0xba, 0x55, 0x8e, 0xba, 0x51, 0x06, 0xba, 0x96, 0xf1, 0xba, 0xb1, 0x5a,
0x5d, 0x27, 0x0c, 0x59, 0x6c, 0x6c, 0xcd, 0x8c, 0x21, 0x56, 0x38, 0xf9, 0x47, 0xf9, 0xa6, 0x67,
0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0x9c, 0xab, 0x0b, 0x71, 0x6e, 0x7a,
0xbe, 0x6e, 0x7a, 0x6a, 0x1e, 0xd8, 0xa5, 0xfa, 0xf8, 0x83, 0xc5, 0x1a, 0xc1, 0x4b, 0x62, 0x03,
0x6b, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x76, 0xaf, 0x2f, 0xc6, 0x4a, 0x01, 0x00, 0x00,
}

630
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/database_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,630 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/database_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDatabaseRequest struct {
// ID of the ClickHouse cluster that the database belongs to.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse Database resource to return.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDatabaseRequest) Reset() { *m = GetDatabaseRequest{} }
func (m *GetDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*GetDatabaseRequest) ProtoMessage() {}
func (*GetDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{0}
}
func (m *GetDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDatabaseRequest.Unmarshal(m, b)
}
func (m *GetDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *GetDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDatabaseRequest.Merge(dst, src)
}
func (m *GetDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_GetDatabaseRequest.Size(m)
}
func (m *GetDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDatabaseRequest proto.InternalMessageInfo
func (m *GetDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *GetDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type ListDatabasesRequest struct {
// ID of the ClickHouse cluster to list databases in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListDatabasesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. to get the next page of results, set [page_token] to the [ListDatabasesResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesRequest) Reset() { *m = ListDatabasesRequest{} }
func (m *ListDatabasesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesRequest) ProtoMessage() {}
func (*ListDatabasesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{1}
}
func (m *ListDatabasesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesRequest.Unmarshal(m, b)
}
func (m *ListDatabasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesRequest.Merge(dst, src)
}
func (m *ListDatabasesRequest) XXX_Size() int {
return xxx_messageInfo_ListDatabasesRequest.Size(m)
}
func (m *ListDatabasesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesRequest proto.InternalMessageInfo
func (m *ListDatabasesRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *ListDatabasesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDatabasesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDatabasesResponse struct {
// List of ClickHouse Database resources.
Databases []*Database `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDatabasesRequest.page_size], use the [next_page_token] as the value
// for the [ListDatabasesRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesResponse) Reset() { *m = ListDatabasesResponse{} }
func (m *ListDatabasesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesResponse) ProtoMessage() {}
func (*ListDatabasesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{2}
}
func (m *ListDatabasesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesResponse.Unmarshal(m, b)
}
func (m *ListDatabasesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesResponse.Merge(dst, src)
}
func (m *ListDatabasesResponse) XXX_Size() int {
return xxx_messageInfo_ListDatabasesResponse.Size(m)
}
func (m *ListDatabasesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesResponse proto.InternalMessageInfo
func (m *ListDatabasesResponse) GetDatabases() []*Database {
if m != nil {
return m.Databases
}
return nil
}
func (m *ListDatabasesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateDatabaseRequest struct {
// ID of the ClickHouse cluster to create a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Configuration of the database to create.
DatabaseSpec *DatabaseSpec `protobuf:"bytes,2,opt,name=database_spec,json=databaseSpec,proto3" json:"database_spec,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseRequest) Reset() { *m = CreateDatabaseRequest{} }
func (m *CreateDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseRequest) ProtoMessage() {}
func (*CreateDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{3}
}
func (m *CreateDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseRequest.Unmarshal(m, b)
}
func (m *CreateDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseRequest.Merge(dst, src)
}
func (m *CreateDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseRequest.Size(m)
}
func (m *CreateDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseRequest proto.InternalMessageInfo
func (m *CreateDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseRequest) GetDatabaseSpec() *DatabaseSpec {
if m != nil {
return m.DatabaseSpec
}
return nil
}
type CreateDatabaseMetadata struct {
// ID of the ClickHouse cluster where a database is being created.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse database that is being created.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseMetadata) Reset() { *m = CreateDatabaseMetadata{} }
func (m *CreateDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseMetadata) ProtoMessage() {}
func (*CreateDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{4}
}
func (m *CreateDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseMetadata.Unmarshal(m, b)
}
func (m *CreateDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseMetadata.Merge(dst, src)
}
func (m *CreateDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseMetadata.Size(m)
}
func (m *CreateDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseMetadata proto.InternalMessageInfo
func (m *CreateDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseRequest struct {
// ID of the ClickHouse cluster to delete a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the database to delete.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseRequest) Reset() { *m = DeleteDatabaseRequest{} }
func (m *DeleteDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseRequest) ProtoMessage() {}
func (*DeleteDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{5}
}
func (m *DeleteDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseRequest.Unmarshal(m, b)
}
func (m *DeleteDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseRequest.Merge(dst, src)
}
func (m *DeleteDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseRequest.Size(m)
}
func (m *DeleteDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseRequest proto.InternalMessageInfo
func (m *DeleteDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseMetadata struct {
// ID of the ClickHouse cluster where a database is being deleted.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse database that is being deleted.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseMetadata) Reset() { *m = DeleteDatabaseMetadata{} }
func (m *DeleteDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseMetadata) ProtoMessage() {}
func (*DeleteDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{6}
}
func (m *DeleteDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseMetadata.Unmarshal(m, b)
}
func (m *DeleteDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseMetadata.Merge(dst, src)
}
func (m *DeleteDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseMetadata.Size(m)
}
func (m *DeleteDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseMetadata proto.InternalMessageInfo
func (m *DeleteDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func init() {
proto.RegisterType((*GetDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetDatabaseRequest")
proto.RegisterType((*ListDatabasesRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListDatabasesRequest")
proto.RegisterType((*ListDatabasesResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListDatabasesResponse")
proto.RegisterType((*CreateDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.CreateDatabaseRequest")
proto.RegisterType((*CreateDatabaseMetadata)(nil), "yandex.cloud.mdb.clickhouse.v1.CreateDatabaseMetadata")
proto.RegisterType((*DeleteDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.DeleteDatabaseRequest")
proto.RegisterType((*DeleteDatabaseMetadata)(nil), "yandex.cloud.mdb.clickhouse.v1.DeleteDatabaseMetadata")
}
// 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
// DatabaseServiceClient is the client API for DatabaseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DatabaseServiceClient interface {
// Returns the specified ClickHouse Database resource.
//
// To get the list of available ClickHouse Database resources, make a [List] request.
Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error)
// Retrieves the list of ClickHouse Database resources in the specified cluster.
List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error)
// Creates a new ClickHouse database in the specified cluster.
Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified ClickHouse database.
Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type databaseServiceClient struct {
cc *grpc.ClientConn
}
func NewDatabaseServiceClient(cc *grpc.ClientConn) DatabaseServiceClient {
return &databaseServiceClient{cc}
}
func (c *databaseServiceClient) Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error) {
out := new(Database)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error) {
out := new(ListDatabasesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DatabaseServiceServer is the server API for DatabaseService service.
type DatabaseServiceServer interface {
// Returns the specified ClickHouse Database resource.
//
// To get the list of available ClickHouse Database resources, make a [List] request.
Get(context.Context, *GetDatabaseRequest) (*Database, error)
// Retrieves the list of ClickHouse Database resources in the specified cluster.
List(context.Context, *ListDatabasesRequest) (*ListDatabasesResponse, error)
// Creates a new ClickHouse database in the specified cluster.
Create(context.Context, *CreateDatabaseRequest) (*operation.Operation, error)
// Deletes the specified ClickHouse database.
Delete(context.Context, *DeleteDatabaseRequest) (*operation.Operation, error)
}
func RegisterDatabaseServiceServer(s *grpc.Server, srv DatabaseServiceServer) {
s.RegisterService(&_DatabaseService_serviceDesc, srv)
}
func _DatabaseService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Get(ctx, req.(*GetDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDatabasesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).List(ctx, req.(*ListDatabasesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Create(ctx, req.(*CreateDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Delete(ctx, req.(*DeleteDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DatabaseService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.DatabaseService",
HandlerType: (*DatabaseServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DatabaseService_Get_Handler,
},
{
MethodName: "List",
Handler: _DatabaseService_List_Handler,
},
{
MethodName: "Create",
Handler: _DatabaseService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _DatabaseService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/database_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/database_service.proto", fileDescriptor_database_service_08aeb62acbe585c3)
}
var fileDescriptor_database_service_08aeb62acbe585c3 = []byte{
// 702 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x4f, 0x13, 0x4b,
0x1c, 0xcd, 0x50, 0x6e, 0x43, 0x07, 0xb8, 0x24, 0x93, 0x5b, 0xd2, 0x34, 0x17, 0xc2, 0xdd, 0x9b,
0x60, 0x53, 0xdd, 0xdd, 0x6e, 0x11, 0xa2, 0x02, 0x26, 0x16, 0x04, 0x4d, 0x04, 0x4c, 0x31, 0x31,
0x41, 0x4c, 0x33, 0xdd, 0xfd, 0xb9, 0x6c, 0x68, 0x77, 0xd7, 0xce, 0xb4, 0xe1, 0x4f, 0x78, 0xd0,
0x07, 0x8d, 0xbc, 0x9a, 0xf8, 0xe6, 0x97, 0x40, 0xbf, 0x03, 0x24, 0xbe, 0xe1, 0x57, 0x30, 0xc6,
0x67, 0x1f, 0x7d, 0x32, 0xbb, 0xd3, 0x6e, 0xbb, 0x50, 0x68, 0x05, 0xde, 0x76, 0xe7, 0xf7, 0x3b,
0x33, 0xe7, 0xcc, 0x9c, 0x33, 0x83, 0x27, 0xb7, 0xa9, 0x6d, 0xc0, 0x96, 0xaa, 0x97, 0x9c, 0xaa,
0xa1, 0x96, 0x8d, 0xa2, 0xaa, 0x97, 0x2c, 0x7d, 0x73, 0xc3, 0xa9, 0x32, 0x50, 0x6b, 0x9a, 0x6a,
0x50, 0x4e, 0x8b, 0x94, 0x41, 0x81, 0x41, 0xa5, 0x66, 0xe9, 0xa0, 0xb8, 0x15, 0x87, 0x3b, 0x64,
0x54, 0xc0, 0x14, 0x1f, 0xa6, 0x94, 0x8d, 0xa2, 0xd2, 0x84, 0x29, 0x35, 0x2d, 0xf9, 0xaf, 0xe9,
0x38, 0x66, 0x09, 0x54, 0xea, 0x5a, 0x2a, 0xb5, 0x6d, 0x87, 0x53, 0x6e, 0x39, 0x36, 0x13, 0xe8,
0x64, 0xb2, 0xbe, 0xa8, 0x57, 0x75, 0x5c, 0xa8, 0xf8, 0xc5, 0x7a, 0x6d, 0x3c, 0x44, 0x28, 0xa8,
0x9e, 0xea, 0x1b, 0x09, 0xf5, 0xd5, 0x68, 0xc9, 0x32, 0x5a, 0xcb, 0x72, 0x97, 0xba, 0x44, 0xbb,
0xf4, 0x06, 0x61, 0xb2, 0x08, 0x7c, 0xbe, 0x3e, 0x9a, 0x87, 0x97, 0x55, 0x60, 0x9c, 0x5c, 0xc7,
0x58, 0x2f, 0x55, 0x19, 0x87, 0x4a, 0xc1, 0x32, 0x12, 0x68, 0x0c, 0xa5, 0x62, 0xb9, 0x81, 0x1f,
0x87, 0x1a, 0xda, 0x3f, 0xd2, 0x7a, 0x67, 0x66, 0x27, 0x33, 0xf9, 0x58, 0xbd, 0xfe, 0xd0, 0x20,
0x73, 0x78, 0x30, 0xd8, 0x2d, 0x9b, 0x96, 0x21, 0xd1, 0xe3, 0xf7, 0x8f, 0x7a, 0xfd, 0x3f, 0x0f,
0xb5, 0xbf, 0x9f, 0x51, 0x79, 0xe7, 0x9e, 0xbc, 0x96, 0x91, 0x6f, 0x17, 0xe4, 0xe7, 0x69, 0x31,
0xc3, 0xd4, 0x44, 0x7e, 0xa0, 0x01, 0x5a, 0xa6, 0x65, 0x90, 0x3e, 0x20, 0xfc, 0xcf, 0x23, 0x8b,
0x05, 0x4c, 0xd8, 0x85, 0xa8, 0x5c, 0xc3, 0x31, 0x97, 0x9a, 0x50, 0x60, 0xd6, 0x8e, 0xa0, 0x11,
0xc9, 0xe1, 0x5f, 0x87, 0x5a, 0x74, 0x66, 0x56, 0xcb, 0x64, 0x32, 0xf9, 0x3e, 0xaf, 0xb8, 0x6a,
0xed, 0x00, 0x49, 0x61, 0xec, 0x37, 0x72, 0x67, 0x13, 0xec, 0x44, 0xc4, 0x9f, 0x35, 0xb6, 0x7f,
0xa4, 0xfd, 0xe5, 0x77, 0xe6, 0xfd, 0x59, 0x9e, 0x78, 0x35, 0xe9, 0x2d, 0xc2, 0xf1, 0x13, 0xc4,
0x98, 0xeb, 0xd8, 0x0c, 0xc8, 0x02, 0x8e, 0x35, 0x24, 0xb0, 0x04, 0x1a, 0x8b, 0xa4, 0xfa, 0xb3,
0x29, 0xe5, 0x7c, 0x7f, 0x28, 0xc1, 0x46, 0x37, 0xa1, 0x64, 0x1c, 0x0f, 0xd9, 0xb0, 0xc5, 0x0b,
0x2d, 0x84, 0xfc, 0x1d, 0xcc, 0x0f, 0x7a, 0xc3, 0x8f, 0x03, 0x26, 0x1f, 0x11, 0x8e, 0xcf, 0x55,
0x80, 0x72, 0xb8, 0xd4, 0x71, 0x3d, 0x6d, 0x39, 0x2e, 0xe6, 0x82, 0xee, 0x2f, 0xd6, 0x9f, 0xbd,
0xd1, 0x2d, 0xf5, 0x55, 0x17, 0xf4, 0x5c, 0xaf, 0x37, 0x7b, 0xf3, 0x08, 0xbd, 0x31, 0x69, 0x1d,
0x0f, 0x87, 0xe9, 0x2d, 0x01, 0xa7, 0x5e, 0x07, 0x19, 0x39, 0xcd, 0xaf, 0x95, 0xd1, 0xff, 0x6d,
0x0d, 0x74, 0xc2, 0x20, 0xef, 0x10, 0x8e, 0xcf, 0x43, 0x09, 0x2e, 0xa9, 0xfe, 0x4a, 0xcc, 0xba,
0x8e, 0x87, 0xc3, 0x54, 0xae, 0x52, 0x69, 0xf6, 0x73, 0x14, 0x0f, 0x05, 0x9b, 0x2d, 0x6e, 0x1f,
0xf2, 0x09, 0xe1, 0xc8, 0x22, 0x70, 0x92, 0xed, 0x74, 0x4a, 0xa7, 0xc3, 0x9c, 0xec, 0xda, 0x94,
0xd2, 0xf2, 0xeb, 0xaf, 0xdf, 0xde, 0xf7, 0x3c, 0x20, 0x0b, 0x6a, 0x99, 0xda, 0xd4, 0x04, 0x43,
0x0e, 0x5f, 0x1e, 0x75, 0x21, 0x4c, 0xdd, 0x6d, 0x8a, 0xdc, 0x0b, 0xae, 0x14, 0xa6, 0xee, 0x86,
0xc4, 0xed, 0x79, 0xac, 0x7b, 0xbd, 0xec, 0x90, 0x9b, 0x9d, 0x28, 0xb4, 0x8b, 0x7e, 0x72, 0xf2,
0x0f, 0x51, 0x22, 0x97, 0xd2, 0x5d, 0x5f, 0xc5, 0x2d, 0x32, 0x75, 0x31, 0x15, 0xe4, 0x0b, 0xc2,
0x51, 0x61, 0x64, 0xd2, 0x91, 0x41, 0xdb, 0x3c, 0x26, 0xff, 0x0b, 0xc3, 0x9a, 0x57, 0xf8, 0x4a,
0xe3, 0x4b, 0x32, 0x0f, 0x8e, 0xd3, 0xd2, 0x99, 0x81, 0xe9, 0x6b, 0x8c, 0xf8, 0x52, 0xa6, 0xa5,
0x0b, 0x4a, 0xb9, 0x83, 0xd2, 0xe4, 0x3b, 0xc2, 0x51, 0x61, 0xd6, 0xce, 0x6a, 0xda, 0xe6, 0xab,
0x1b, 0x35, 0xaf, 0xd0, 0xc1, 0x71, 0x5a, 0x3d, 0x33, 0x15, 0x71, 0xf1, 0x2a, 0x8a, 0x37, 0xa7,
0x58, 0x7d, 0xa1, 0xdc, 0x2f, 0xbb, 0x7c, 0x5b, 0x98, 0x2d, 0x7d, 0x45, 0x66, 0xcb, 0xad, 0xac,
0x2d, 0x99, 0x16, 0xdf, 0xa8, 0x16, 0x15, 0xdd, 0x29, 0xab, 0x82, 0xb2, 0x2c, 0x9e, 0x41, 0xd3,
0x91, 0x4d, 0xb0, 0xfd, 0xd5, 0xd5, 0xf3, 0xdf, 0xc7, 0xe9, 0xe6, 0x5f, 0x31, 0xea, 0x03, 0x26,
0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x9e, 0x81, 0xf7, 0x00, 0x2b, 0x08, 0x00, 0x00,
}

112
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/resource_preset.pb.go generated vendored Normal file
View File

@ -0,0 +1,112 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/resource_preset.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A ResourcePreset resource for describing hardware configuration presets.
type ResourcePreset struct {
// ID of the ResourcePreset resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// IDs of availability zones where the resource preset is available.
ZoneIds []string `protobuf:"bytes,2,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
// Number of CPU cores for a ClickHouse host created with the preset.
Cores int64 `protobuf:"varint,3,opt,name=cores,proto3" json:"cores,omitempty"`
// RAM volume for a ClickHouse host created with the preset, in bytes.
Memory int64 `protobuf:"varint,4,opt,name=memory,proto3" json:"memory,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ResourcePreset) Reset() { *m = ResourcePreset{} }
func (m *ResourcePreset) String() string { return proto.CompactTextString(m) }
func (*ResourcePreset) ProtoMessage() {}
func (*ResourcePreset) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_8b47fe1881d4dab9, []int{0}
}
func (m *ResourcePreset) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ResourcePreset.Unmarshal(m, b)
}
func (m *ResourcePreset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ResourcePreset.Marshal(b, m, deterministic)
}
func (dst *ResourcePreset) XXX_Merge(src proto.Message) {
xxx_messageInfo_ResourcePreset.Merge(dst, src)
}
func (m *ResourcePreset) XXX_Size() int {
return xxx_messageInfo_ResourcePreset.Size(m)
}
func (m *ResourcePreset) XXX_DiscardUnknown() {
xxx_messageInfo_ResourcePreset.DiscardUnknown(m)
}
var xxx_messageInfo_ResourcePreset proto.InternalMessageInfo
func (m *ResourcePreset) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ResourcePreset) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func (m *ResourcePreset) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *ResourcePreset) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func init() {
proto.RegisterType((*ResourcePreset)(nil), "yandex.cloud.mdb.clickhouse.v1.ResourcePreset")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/resource_preset.proto", fileDescriptor_resource_preset_8b47fe1881d4dab9)
}
var fileDescriptor_resource_preset_8b47fe1881d4dab9 = []byte{
// 215 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0xcf, 0xb1, 0x4b, 0x03, 0x31,
0x14, 0xc7, 0x71, 0xee, 0x4e, 0xab, 0xcd, 0xd0, 0x21, 0x88, 0xc4, 0x45, 0x0e, 0xa7, 0x5b, 0x9a,
0x50, 0x74, 0x73, 0x73, 0x73, 0x10, 0x25, 0xa3, 0x4b, 0x31, 0x79, 0x8f, 0x6b, 0xb0, 0xb9, 0x57,
0x92, 0x4b, 0xb1, 0xfe, 0xf5, 0x62, 0x72, 0x70, 0x5b, 0xc7, 0xef, 0x83, 0x0f, 0xbc, 0x1f, 0x7b,
0x3a, 0x7d, 0x0d, 0x80, 0x3f, 0xca, 0xee, 0x29, 0x81, 0xf2, 0x60, 0x94, 0xdd, 0x3b, 0xfb, 0xbd,
0xa3, 0x14, 0x51, 0x1d, 0x37, 0x2a, 0x60, 0xa4, 0x14, 0x2c, 0x6e, 0x0f, 0x01, 0x23, 0x8e, 0xf2,
0x10, 0x68, 0x24, 0x7e, 0x5f, 0x94, 0xcc, 0x4a, 0x7a, 0x30, 0x72, 0x56, 0xf2, 0xb8, 0x79, 0x70,
0x6c, 0xa5, 0x27, 0xf8, 0x91, 0x1d, 0x5f, 0xb1, 0xda, 0x81, 0xa8, 0xda, 0xaa, 0x5b, 0xea, 0xda,
0x01, 0xbf, 0x63, 0xd7, 0xbf, 0x34, 0xe0, 0xd6, 0x41, 0x14, 0x75, 0xdb, 0x74, 0x4b, 0x7d, 0xf5,
0xdf, 0xaf, 0x10, 0xf9, 0x0d, 0xbb, 0xb4, 0x14, 0x30, 0x8a, 0xa6, 0xad, 0xba, 0x46, 0x97, 0xe0,
0xb7, 0x6c, 0xe1, 0xd1, 0x53, 0x38, 0x89, 0x8b, 0x7c, 0x9e, 0xea, 0xe5, 0xfd, 0xf3, 0xad, 0x77,
0xe3, 0x2e, 0x19, 0x69, 0xc9, 0xab, 0xf2, 0xd7, 0xba, 0xac, 0xe9, 0x69, 0xdd, 0xe3, 0x90, 0x3f,
0x56, 0xe7, 0x67, 0x3e, 0xcf, 0x65, 0x16, 0x19, 0x3c, 0xfe, 0x05, 0x00, 0x00, 0xff, 0xff, 0x10,
0xb1, 0xd0, 0xe7, 0x1a, 0x01, 0x00, 0x00,
}

325
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/resource_preset_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,325 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetResourcePresetRequest struct {
// ID of the resource preset to return.
// To get the resource preset ID, use a [ResourcePresetService.List] request.
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetResourcePresetRequest) Reset() { *m = GetResourcePresetRequest{} }
func (m *GetResourcePresetRequest) String() string { return proto.CompactTextString(m) }
func (*GetResourcePresetRequest) ProtoMessage() {}
func (*GetResourcePresetRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{0}
}
func (m *GetResourcePresetRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetResourcePresetRequest.Unmarshal(m, b)
}
func (m *GetResourcePresetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetResourcePresetRequest.Marshal(b, m, deterministic)
}
func (dst *GetResourcePresetRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetResourcePresetRequest.Merge(dst, src)
}
func (m *GetResourcePresetRequest) XXX_Size() int {
return xxx_messageInfo_GetResourcePresetRequest.Size(m)
}
func (m *GetResourcePresetRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetResourcePresetRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetResourcePresetRequest proto.InternalMessageInfo
func (m *GetResourcePresetRequest) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
type ListResourcePresetsRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListResourcePresetsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, Set [page_token] to the [ListResourcePresetsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsRequest) Reset() { *m = ListResourcePresetsRequest{} }
func (m *ListResourcePresetsRequest) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsRequest) ProtoMessage() {}
func (*ListResourcePresetsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{1}
}
func (m *ListResourcePresetsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsRequest.Unmarshal(m, b)
}
func (m *ListResourcePresetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsRequest.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsRequest.Merge(dst, src)
}
func (m *ListResourcePresetsRequest) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsRequest.Size(m)
}
func (m *ListResourcePresetsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsRequest proto.InternalMessageInfo
func (m *ListResourcePresetsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListResourcePresetsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListResourcePresetsResponse struct {
// List of ResourcePreset resources.
ResourcePresets []*ResourcePreset `protobuf:"bytes,1,rep,name=resource_presets,json=resourcePresets,proto3" json:"resource_presets,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListResourcePresetsRequest.page_size], use the [next_page_token] as the value
// for the [ListResourcePresetsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsResponse) Reset() { *m = ListResourcePresetsResponse{} }
func (m *ListResourcePresetsResponse) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsResponse) ProtoMessage() {}
func (*ListResourcePresetsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{2}
}
func (m *ListResourcePresetsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsResponse.Unmarshal(m, b)
}
func (m *ListResourcePresetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsResponse.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsResponse.Merge(dst, src)
}
func (m *ListResourcePresetsResponse) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsResponse.Size(m)
}
func (m *ListResourcePresetsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsResponse proto.InternalMessageInfo
func (m *ListResourcePresetsResponse) GetResourcePresets() []*ResourcePreset {
if m != nil {
return m.ResourcePresets
}
return nil
}
func (m *ListResourcePresetsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetResourcePresetRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetResourcePresetRequest")
proto.RegisterType((*ListResourcePresetsRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListResourcePresetsRequest")
proto.RegisterType((*ListResourcePresetsResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListResourcePresetsResponse")
}
// 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
// ResourcePresetServiceClient is the client API for ResourcePresetService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ResourcePresetServiceClient interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error)
}
type resourcePresetServiceClient struct {
cc *grpc.ClientConn
}
func NewResourcePresetServiceClient(cc *grpc.ClientConn) ResourcePresetServiceClient {
return &resourcePresetServiceClient{cc}
}
func (c *resourcePresetServiceClient) Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error) {
out := new(ResourcePreset)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourcePresetServiceClient) List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error) {
out := new(ListResourcePresetsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ResourcePresetServiceServer is the server API for ResourcePresetService service.
type ResourcePresetServiceServer interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(context.Context, *GetResourcePresetRequest) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(context.Context, *ListResourcePresetsRequest) (*ListResourcePresetsResponse, error)
}
func RegisterResourcePresetServiceServer(s *grpc.Server, srv ResourcePresetServiceServer) {
s.RegisterService(&_ResourcePresetService_serviceDesc, srv)
}
func _ResourcePresetService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetResourcePresetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).Get(ctx, req.(*GetResourcePresetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourcePresetService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListResourcePresetsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).List(ctx, req.(*ListResourcePresetsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ResourcePresetService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.ResourcePresetService",
HandlerType: (*ResourcePresetServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourcePresetService_Get_Handler,
},
{
MethodName: "List",
Handler: _ResourcePresetService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto", fileDescriptor_resource_preset_service_3c94510b9cb0b96a)
}
var fileDescriptor_resource_preset_service_3c94510b9cb0b96a = []byte{
// 470 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0x4d, 0x6b, 0x13, 0x41,
0x18, 0x66, 0xba, 0xb5, 0x98, 0x51, 0x69, 0x19, 0x10, 0x96, 0xf5, 0x83, 0xb0, 0x87, 0xba, 0x97,
0xcc, 0x64, 0xab, 0x82, 0x34, 0xc9, 0x25, 0x1e, 0x8a, 0xa0, 0x58, 0xb6, 0x22, 0xe8, 0x25, 0x4c,
0x76, 0x5e, 0xb6, 0x43, 0x93, 0x99, 0x75, 0x67, 0x36, 0xd4, 0x8a, 0x20, 0x1e, 0x7b, 0xf5, 0x0f,
0xf8, 0x0f, 0xbc, 0xf8, 0x1f, 0xda, 0xbb, 0x7f, 0xc1, 0x83, 0xbf, 0xc1, 0x93, 0xec, 0x6c, 0x4a,
0x4d, 0xec, 0x87, 0xe9, 0x71, 0xf7, 0x99, 0xe7, 0x79, 0xde, 0xe7, 0xfd, 0xc0, 0xdd, 0xf7, 0x5c,
0x09, 0xd8, 0x67, 0xe9, 0x48, 0x97, 0x82, 0x8d, 0xc5, 0x90, 0xa5, 0x23, 0x99, 0xee, 0xed, 0xea,
0xd2, 0x00, 0x9b, 0xc4, 0xac, 0x00, 0xa3, 0xcb, 0x22, 0x85, 0x41, 0x5e, 0x80, 0x01, 0x3b, 0x30,
0x50, 0x4c, 0x64, 0x0a, 0x34, 0x2f, 0xb4, 0xd5, 0xe4, 0x7e, 0xcd, 0xa6, 0x8e, 0x4d, 0xc7, 0x62,
0x48, 0x4f, 0xd9, 0x74, 0x12, 0x07, 0x77, 0x33, 0xad, 0xb3, 0x11, 0x30, 0x9e, 0x4b, 0xc6, 0x95,
0xd2, 0x96, 0x5b, 0xa9, 0x95, 0xa9, 0xd9, 0xc1, 0xbd, 0x19, 0xef, 0x09, 0x1f, 0x49, 0xe1, 0xf0,
0x29, 0xfc, 0x68, 0xb1, 0xd2, 0x6a, 0x56, 0xf8, 0x1a, 0xfb, 0x5b, 0x60, 0x93, 0x29, 0xb6, 0xed,
0xa0, 0x04, 0xde, 0x95, 0x60, 0x2c, 0xd9, 0xc4, 0x64, 0x3e, 0x8f, 0x14, 0x3e, 0x6a, 0xa2, 0xa8,
0xd1, 0xbf, 0xf9, 0xeb, 0x28, 0x46, 0x87, 0xc7, 0xf1, 0x72, 0xb7, 0xf7, 0xb8, 0x9d, 0xac, 0x15,
0x33, 0x02, 0xcf, 0x44, 0xa8, 0x71, 0xf0, 0x5c, 0x9a, 0x39, 0x61, 0x73, 0xa2, 0xfc, 0x00, 0x37,
0x72, 0x9e, 0xc1, 0xc0, 0xc8, 0x03, 0xf0, 0x97, 0x9a, 0x28, 0xf2, 0xfa, 0xf8, 0xf7, 0x51, 0xbc,
0xd2, 0xed, 0xc5, 0xed, 0x76, 0x3b, 0xb9, 0x5e, 0x81, 0x3b, 0xf2, 0x00, 0x48, 0x84, 0xb1, 0x7b,
0x68, 0xf5, 0x1e, 0x28, 0xdf, 0x73, 0xd6, 0x8d, 0xc3, 0xe3, 0xf8, 0x9a, 0x7b, 0x99, 0x38, 0x95,
0x57, 0x15, 0x16, 0x7e, 0x45, 0xf8, 0xce, 0x99, 0x8e, 0x26, 0xd7, 0xca, 0x00, 0x79, 0x83, 0xd7,
0xe6, 0xc2, 0x18, 0x1f, 0x35, 0xbd, 0xe8, 0xc6, 0x06, 0xa5, 0x17, 0x8f, 0x85, 0xce, 0x75, 0x67,
0x75, 0x36, 0xac, 0x21, 0xeb, 0x78, 0x55, 0xc1, 0xbe, 0x1d, 0xfc, 0x55, 0x69, 0x95, 0xa9, 0x91,
0xdc, 0xaa, 0x7e, 0x6f, 0x9f, 0x94, 0xb8, 0xf1, 0xc9, 0xc3, 0xb7, 0x67, 0xb5, 0x76, 0xea, 0xf5,
0x20, 0xdf, 0x11, 0xf6, 0xb6, 0xc0, 0x92, 0x27, 0x97, 0x95, 0x72, 0xde, 0xac, 0x82, 0x05, 0x43,
0x84, 0x4f, 0x3f, 0xff, 0xf8, 0xf9, 0x65, 0xa9, 0x47, 0x3a, 0x6c, 0xcc, 0x15, 0xcf, 0x40, 0xb4,
0xce, 0xde, 0x96, 0x69, 0x46, 0xf6, 0xe1, 0xdf, 0x4d, 0xf8, 0x48, 0xbe, 0x21, 0xbc, 0x5c, 0xf5,
0x9c, 0x6c, 0x5e, 0xe6, 0x7e, 0xfe, 0x2e, 0x04, 0x9d, 0x2b, 0x71, 0xeb, 0xa9, 0x86, 0xd4, 0xc5,
0x88, 0xc8, 0xfa, 0xff, 0xc5, 0xe8, 0xbf, 0x7c, 0xfb, 0x22, 0x93, 0x76, 0xb7, 0x1c, 0xd2, 0x54,
0x8f, 0x59, 0x6d, 0xdc, 0xaa, 0x2f, 0x26, 0xd3, 0xad, 0x0c, 0x94, 0xbb, 0x0a, 0x76, 0xf1, 0x29,
0x75, 0x4e, 0xbf, 0x86, 0x2b, 0x8e, 0xf0, 0xf0, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xea,
0x85, 0x77, 0x19, 0x04, 0x00, 0x00,
}

210
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/user.pb.go generated vendored Normal file
View File

@ -0,0 +1,210 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/user.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse User resource. For more information, see
// the [Developer's guide](/docs/managed-clickhouse/concepts).
type User struct {
// Name of the ClickHouse user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the ClickHouse cluster the user belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Set of permissions granted to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{0}
}
func (m *User) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_User.Unmarshal(m, b)
}
func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_User.Marshal(b, m, deterministic)
}
func (dst *User) XXX_Merge(src proto.Message) {
xxx_messageInfo_User.Merge(dst, src)
}
func (m *User) XXX_Size() int {
return xxx_messageInfo_User.Size(m)
}
func (m *User) XXX_DiscardUnknown() {
xxx_messageInfo_User.DiscardUnknown(m)
}
var xxx_messageInfo_User proto.InternalMessageInfo
func (m *User) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *User) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *User) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
type Permission struct {
// Name of the database that the permission grants access to.
DatabaseName string `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Permission) Reset() { *m = Permission{} }
func (m *Permission) String() string { return proto.CompactTextString(m) }
func (*Permission) ProtoMessage() {}
func (*Permission) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{1}
}
func (m *Permission) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Permission.Unmarshal(m, b)
}
func (m *Permission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Permission.Marshal(b, m, deterministic)
}
func (dst *Permission) XXX_Merge(src proto.Message) {
xxx_messageInfo_Permission.Merge(dst, src)
}
func (m *Permission) XXX_Size() int {
return xxx_messageInfo_Permission.Size(m)
}
func (m *Permission) XXX_DiscardUnknown() {
xxx_messageInfo_Permission.DiscardUnknown(m)
}
var xxx_messageInfo_Permission proto.InternalMessageInfo
func (m *Permission) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type UserSpec struct {
// Name of the ClickHouse user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Password of the ClickHouse user.
Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
// Set of permissions to grant to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserSpec) Reset() { *m = UserSpec{} }
func (m *UserSpec) String() string { return proto.CompactTextString(m) }
func (*UserSpec) ProtoMessage() {}
func (*UserSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{2}
}
func (m *UserSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserSpec.Unmarshal(m, b)
}
func (m *UserSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserSpec.Marshal(b, m, deterministic)
}
func (dst *UserSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserSpec.Merge(dst, src)
}
func (m *UserSpec) XXX_Size() int {
return xxx_messageInfo_UserSpec.Size(m)
}
func (m *UserSpec) XXX_DiscardUnknown() {
xxx_messageInfo_UserSpec.DiscardUnknown(m)
}
var xxx_messageInfo_UserSpec proto.InternalMessageInfo
func (m *UserSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UserSpec) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
func (m *UserSpec) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
func init() {
proto.RegisterType((*User)(nil), "yandex.cloud.mdb.clickhouse.v1.User")
proto.RegisterType((*Permission)(nil), "yandex.cloud.mdb.clickhouse.v1.Permission")
proto.RegisterType((*UserSpec)(nil), "yandex.cloud.mdb.clickhouse.v1.UserSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/user.proto", fileDescriptor_user_002833f6340c62e6)
}
var fileDescriptor_user_002833f6340c62e6 = []byte{
// 332 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xac, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0x4f, 0xce, 0xc9,
0x4c, 0xce, 0xce, 0xc8, 0x2f, 0x2d, 0x4e, 0xd5, 0x2f, 0x33, 0xd4, 0x2f, 0x2d, 0x4e, 0x2d, 0xd2,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x83, 0x28, 0xd5, 0x03, 0x2b, 0xd5, 0xcb, 0x4d, 0x49,
0xd2, 0x43, 0x28, 0xd5, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xaa, 0x2c, 0x31, 0x27, 0x33, 0x25,
0xb1, 0x24, 0x33, 0x3f, 0x0f, 0xa2, 0x5d, 0xa9, 0x9d, 0x91, 0x8b, 0x25, 0xb4, 0x38, 0xb5, 0x48,
0x48, 0x88, 0x8b, 0x25, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xcc,
0x16, 0x92, 0xe5, 0xe2, 0x4a, 0xce, 0x29, 0x2d, 0x2e, 0x49, 0x2d, 0x8a, 0xcf, 0x4c, 0x91, 0x60,
0x02, 0xcb, 0x70, 0x42, 0x45, 0x3c, 0x53, 0x84, 0x7c, 0xb8, 0xb8, 0x0b, 0x52, 0x8b, 0x72, 0x33,
0x8b, 0x8b, 0x33, 0xf3, 0xf3, 0x8a, 0x25, 0x98, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0xb4, 0xf4, 0xf0,
0x3b, 0x48, 0x2f, 0x00, 0xae, 0x25, 0x08, 0x59, 0xbb, 0x92, 0x21, 0x17, 0x17, 0x42, 0x4a, 0x48,
0x99, 0x8b, 0x37, 0x25, 0xb1, 0x24, 0x31, 0x29, 0xb1, 0x38, 0x35, 0x1e, 0xc9, 0x5d, 0x3c, 0x30,
0x41, 0xbf, 0xc4, 0xdc, 0x54, 0xa5, 0x6d, 0x8c, 0x5c, 0x1c, 0x20, 0xc7, 0x07, 0x17, 0xa4, 0x26,
0x0b, 0x19, 0x22, 0x7b, 0xc0, 0x49, 0xf6, 0xc5, 0x71, 0x43, 0xc6, 0x4f, 0xc7, 0x0d, 0x79, 0xa3,
0x13, 0x75, 0xab, 0x1c, 0x75, 0xa3, 0x0c, 0x74, 0x2d, 0xe3, 0x63, 0xb5, 0xba, 0x4e, 0x18, 0xb2,
0xd8, 0xd8, 0x9a, 0x19, 0x43, 0xfd, 0xa7, 0xc9, 0xc5, 0x51, 0x90, 0x58, 0x5c, 0x5c, 0x9e, 0x5f,
0x04, 0xf5, 0x9d, 0x13, 0x2f, 0x48, 0x5b, 0xd7, 0x09, 0x43, 0x56, 0x0b, 0x5d, 0x43, 0x23, 0x8b,
0x20, 0xb8, 0x34, 0x75, 0xfd, 0xea, 0xe4, 0x1f, 0xe5, 0x9b, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4,
0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x31, 0x44, 0x17, 0x12, 0x43, 0xe9, 0xf9, 0xba, 0xe9, 0xa9, 0x79,
0xe0, 0xc8, 0xd1, 0xc7, 0x9f, 0x0a, 0xac, 0x11, 0xbc, 0x24, 0x36, 0xb0, 0x06, 0x63, 0x40, 0x00,
0x00, 0x00, 0xff, 0xff, 0x8b, 0x24, 0x59, 0x97, 0x39, 0x02, 0x00, 0x00,
}

1099
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/user_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

138
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,138 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/backup.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
// A MongoDB Backup resource. For more information, see the
// [Developer's Guide](/docs/managed-mongodb/concepts).
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the MongoDB cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
// Time when the backup operation was started.
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
// Shard names used as a source for backup.
SourceShardNames []string `protobuf:"bytes,6,rep,name=source_shard_names,json=sourceShardNames,proto3" json:"source_shard_names,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_8bb497f900b870bf, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func (m *Backup) GetSourceShardNames() []string {
if m != nil {
return m.SourceShardNames
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.mongodb.v1.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/backup.proto", fileDescriptor_backup_8bb497f900b870bf)
}
var fileDescriptor_backup_8bb497f900b870bf = []byte{
// 290 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xbd, 0x4e, 0xf3, 0x30,
0x18, 0x85, 0xd5, 0xf4, 0xfb, 0x2a, 0x62, 0x24, 0x7e, 0x3c, 0x45, 0xed, 0x40, 0xc5, 0x14, 0x21,
0x6a, 0xab, 0x30, 0x21, 0xa6, 0x96, 0x01, 0x75, 0x61, 0x28, 0x4c, 0x2c, 0x91, 0xed, 0xd7, 0x75,
0x23, 0xe2, 0xb8, 0xf2, 0x4f, 0x05, 0x17, 0xc0, 0x7d, 0xa3, 0xda, 0xee, 0x0a, 0x5b, 0x74, 0xce,
0x93, 0xf3, 0x48, 0xaf, 0x51, 0xfd, 0xc5, 0x7a, 0x90, 0x9f, 0x54, 0x74, 0x26, 0x00, 0xd5, 0xc0,
0xa9, 0x36, 0xbd, 0x32, 0xc0, 0xe9, 0x7e, 0x4e, 0x39, 0x13, 0x1f, 0x61, 0x47, 0x76, 0xd6, 0x78,
0x83, 0x27, 0x89, 0x24, 0x91, 0x24, 0x1a, 0x38, 0xc9, 0x24, 0xd9, 0xcf, 0xc7, 0x57, 0xca, 0x18,
0xd5, 0x49, 0x1a, 0x51, 0x1e, 0x36, 0xd4, 0xb7, 0x5a, 0x3a, 0xcf, 0x74, 0xfe, 0xfb, 0xfa, 0xbb,
0x40, 0xa3, 0x65, 0x9c, 0xc3, 0x67, 0xa8, 0x68, 0xa1, 0x1a, 0x4c, 0x07, 0x75, 0xb9, 0x2e, 0x5a,
0xc0, 0x13, 0x54, 0x6e, 0x4c, 0x07, 0xd2, 0x36, 0x2d, 0x54, 0x45, 0x8c, 0x4f, 0x52, 0xb0, 0x02,
0xfc, 0x80, 0x90, 0xb0, 0x92, 0x79, 0x09, 0x0d, 0xf3, 0xd5, 0x70, 0x3a, 0xa8, 0x4f, 0xef, 0xc6,
0x24, 0xd9, 0xc8, 0xd1, 0x46, 0xde, 0x8e, 0xb6, 0x75, 0x99, 0xe9, 0x85, 0xc7, 0x37, 0xe8, 0xd2,
0x99, 0x60, 0x85, 0x6c, 0x44, 0x17, 0x9c, 0x4f, 0xfb, 0xff, 0xe2, 0xfe, 0x79, 0x2a, 0x9e, 0x52,
0x9e, 0x34, 0xce, 0x33, 0x9b, 0x35, 0xff, 0xff, 0xd6, 0x64, 0x7a, 0xe1, 0xf1, 0x2d, 0xc2, 0x59,
0xe3, 0xb6, 0xcc, 0x42, 0xd3, 0x33, 0x2d, 0x5d, 0x35, 0x9a, 0x0e, 0xeb, 0x72, 0x7d, 0x91, 0x9a,
0xd7, 0x43, 0xf1, 0x72, 0xc8, 0x97, 0xab, 0xf7, 0x67, 0xd5, 0xfa, 0x6d, 0xe0, 0x44, 0x18, 0x4d,
0xd3, 0x49, 0x67, 0xe9, 0xf8, 0xca, 0xcc, 0x94, 0xec, 0xa3, 0x8c, 0xfe, 0xf2, 0x2a, 0x8f, 0xf9,
0x93, 0x8f, 0x22, 0x7a, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xb9, 0x9c, 0x42, 0xc3, 0x01,
0x00, 0x00,
}

331
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,331 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/backup_service.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// 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.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the backup to return information about.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListBackupsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// List of Backup resources.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.mongodb.v1.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.mongodb.v1.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.mongodb.v1.ListBackupsResponse")
}
// 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
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified MongoDB Backup resource.
//
// To get the list of available MongoDB Backup resources, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified MongoDB Backup resource.
//
// To get the list of available MongoDB Backup resources, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.mongodb.v1.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/mongodb/v1/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/backup_service.proto", fileDescriptor_backup_service_8136fe766e84b00c)
}
var fileDescriptor_backup_service_8136fe766e84b00c = []byte{
// 459 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x31, 0x6f, 0xd3, 0x40,
0x14, 0xc7, 0xe5, 0x24, 0x94, 0xf8, 0xa0, 0x02, 0x1d, 0x4b, 0x94, 0x52, 0x29, 0xb8, 0x12, 0x75,
0x87, 0xf8, 0xec, 0xa2, 0x4e, 0x34, 0x4b, 0x96, 0x28, 0x12, 0x03, 0x72, 0x99, 0x58, 0xa2, 0x73,
0xee, 0x71, 0x9c, 0x1a, 0xdf, 0x99, 0xdc, 0xc5, 0x2a, 0x05, 0x16, 0xc6, 0x0c, 0x0c, 0xf0, 0x39,
0xf8, 0x1c, 0xed, 0xce, 0x57, 0x60, 0xe0, 0x33, 0x30, 0x21, 0xdf, 0x39, 0x40, 0xa9, 0x64, 0xba,
0x9d, 0xee, 0xff, 0x7e, 0xef, 0xfd, 0xf5, 0x7f, 0x0f, 0xc5, 0x6f, 0xa9, 0x64, 0x70, 0x46, 0xe6,
0x0b, 0xb5, 0x62, 0x24, 0x67, 0x19, 0xc9, 0x95, 0xe4, 0x8a, 0x65, 0xa4, 0x4c, 0x48, 0x46, 0xe7,
0xa7, 0xab, 0x62, 0xa6, 0x61, 0x59, 0x8a, 0x39, 0x44, 0xc5, 0x52, 0x19, 0x85, 0x77, 0x1c, 0x11,
0x59, 0x22, 0xca, 0x59, 0x16, 0xd5, 0x44, 0x54, 0x26, 0xfd, 0x87, 0x5c, 0x29, 0xbe, 0x00, 0x42,
0x0b, 0x41, 0xa8, 0x94, 0xca, 0x50, 0x23, 0x94, 0xd4, 0x0e, 0xed, 0xef, 0x5e, 0x19, 0x56, 0xd2,
0x85, 0x60, 0x56, 0xaf, 0xe5, 0xf0, 0xff, 0x5e, 0x5c, 0x65, 0x70, 0x84, 0xee, 0x4f, 0xc0, 0x8c,
0xed, 0x57, 0x0a, 0x6f, 0x56, 0xa0, 0x0d, 0x7e, 0x84, 0xfc, 0xda, 0xaf, 0x60, 0x3d, 0x6f, 0xe0,
0x85, 0xfe, 0xb8, 0xf3, 0xe3, 0x22, 0xf1, 0xd2, 0xae, 0xfb, 0x9e, 0xb2, 0xe0, 0xb3, 0x87, 0xf0,
0x33, 0xa1, 0x6b, 0x50, 0x6f, 0xc8, 0x03, 0xe4, 0xbf, 0x52, 0x0b, 0x06, 0xcb, 0x3f, 0xe4, 0xdd,
0x8a, 0x5c, 0x5f, 0x26, 0x9d, 0xe3, 0xd1, 0x51, 0x9c, 0x76, 0x9d, 0x3c, 0x65, 0x78, 0x1f, 0xf9,
0x05, 0xe5, 0x30, 0xd3, 0xe2, 0x1c, 0x7a, 0xad, 0x81, 0x17, 0xb6, 0xc7, 0xe8, 0xe7, 0x45, 0xb2,
0x75, 0x3c, 0x4a, 0xe2, 0x38, 0x4e, 0xbb, 0x95, 0x78, 0x22, 0xce, 0x01, 0x87, 0x08, 0xd9, 0x42,
0xa3, 0x4e, 0x41, 0xf6, 0xda, 0xb6, 0xa9, 0xbf, 0xbe, 0x4c, 0x6e, 0xd9, 0xca, 0xd4, 0x76, 0x79,
0x51, 0x69, 0xc1, 0x7b, 0xf4, 0xe0, 0x8a, 0x27, 0x5d, 0x28, 0xa9, 0x01, 0x8f, 0xd0, 0x6d, 0xe7,
0x5b, 0xf7, 0xbc, 0x41, 0x3b, 0xbc, 0x73, 0xb8, 0x17, 0x35, 0x04, 0x1f, 0xd5, 0x59, 0x6c, 0x18,
0xfc, 0x18, 0xdd, 0x93, 0x70, 0x66, 0x66, 0x7f, 0x99, 0xa8, 0xec, 0xfa, 0xe9, 0x76, 0xf5, 0xfd,
0x7c, 0x33, 0xfd, 0xf0, 0x6b, 0x0b, 0x6d, 0x3b, 0xf6, 0xc4, 0x6d, 0x19, 0xaf, 0x3d, 0xd4, 0x9e,
0x80, 0xc1, 0xc3, 0xc6, 0x79, 0xff, 0xc6, 0xdf, 0xbf, 0x89, 0xbd, 0x80, 0x7c, 0xfc, 0xf6, 0xfd,
0x4b, 0xeb, 0x00, 0xef, 0x93, 0x9c, 0x4a, 0xca, 0x81, 0x0d, 0xaf, 0x6d, 0x58, 0x93, 0x77, 0xbf,
0xd7, 0xf8, 0x01, 0x7f, 0xf2, 0x50, 0xa7, 0x4a, 0x07, 0x93, 0xc6, 0xf6, 0xd7, 0x97, 0xda, 0x8f,
0x6f, 0x0e, 0xb8, 0xc4, 0x83, 0x3d, 0x6b, 0x6e, 0x17, 0xef, 0x34, 0x98, 0x1b, 0x4f, 0x5f, 0x4e,
0xb8, 0x30, 0xaf, 0x57, 0x59, 0x34, 0x57, 0x39, 0x71, 0x23, 0x86, 0xee, 0x60, 0xb9, 0x1a, 0x72,
0x90, 0xf6, 0x40, 0x49, 0xc3, 0x25, 0x3f, 0xad, 0x9f, 0xd9, 0x96, 0x2d, 0x7d, 0xf2, 0x2b, 0x00,
0x00, 0xff, 0xff, 0x1f, 0x32, 0xcb, 0x4a, 0x83, 0x03, 0x00, 0x00,
}

1224
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/cluster.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

3733
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More