github.com/grailbio/base@v0.0.11/security/identity/identity.vdl.go

// This file was auto-generated by the vanadium vdl tool.
// Package: identity

// Package identity defines interfaces for Vanadium identity providers.
//nolint:golint
package identity

import (
	v23 "v.io/v23"
	"v.io/v23/context"
	"v.io/v23/rpc"
	"v.io/v23/security"
	"v.io/v23/security/access"
	"v.io/v23/vdl"
)

var _ = initializeVDL() // Must be first; see initializeVDL comments for details.

// Interface definitions
// =====================

// Ec2BlesserClientMethods is the client interface
// containing Ec2Blesser methods.
//
// Ec2Blesser returns a blessing given the provided EC2 instance identity
// document.
type Ec2BlesserClientMethods interface {
	// BlessEc2 uses the provided EC2 instance identity document in PKCS#7
	// format to return a blessing to the client.
	BlessEc2(_ *context.T, pkcs7b64 string, _ ...rpc.CallOpt) (blessing security.Blessings, _ error)
}

// Ec2BlesserClientStub embeds Ec2BlesserClientMethods and is a
// placeholder for additional management operations.
type Ec2BlesserClientStub interface {
	Ec2BlesserClientMethods
}

// Ec2BlesserClient returns a client stub for Ec2Blesser.
func Ec2BlesserClient(name string) Ec2BlesserClientStub {
	return implEc2BlesserClientStub{name}
}

type implEc2BlesserClientStub struct {
	name string
}

func (c implEc2BlesserClientStub) BlessEc2(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 security.Blessings, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "BlessEc2", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

// Ec2BlesserServerMethods is the interface a server writer
// implements for Ec2Blesser.
//
// Ec2Blesser returns a blessing given the provided EC2 instance identity
// document.
type Ec2BlesserServerMethods interface {
	// BlessEc2 uses the provided EC2 instance identity document in PKCS#7
	// format to return a blessing to the client.
	BlessEc2(_ *context.T, _ rpc.ServerCall, pkcs7b64 string) (blessing security.Blessings, _ error)
}

// Ec2BlesserServerStubMethods is the server interface containing
// Ec2Blesser methods, as expected by rpc.Server.
// There is no difference between this interface and Ec2BlesserServerMethods
// since there are no streaming methods.
type Ec2BlesserServerStubMethods Ec2BlesserServerMethods

// Ec2BlesserServerStub adds universal methods to Ec2BlesserServerStubMethods.
type Ec2BlesserServerStub interface {
	Ec2BlesserServerStubMethods
	// DescribeInterfaces the Ec2Blesser interfaces.
	Describe__() []rpc.InterfaceDesc
}

// Ec2BlesserServer returns a server stub for Ec2Blesser.
// It converts an implementation of Ec2BlesserServerMethods into
// an object that may be used by rpc.Server.
func Ec2BlesserServer(impl Ec2BlesserServerMethods) Ec2BlesserServerStub {
	stub := implEc2BlesserServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implEc2BlesserServerStub struct {
	impl Ec2BlesserServerMethods
	gs   *rpc.GlobState
}

func (s implEc2BlesserServerStub) BlessEc2(ctx *context.T, call rpc.ServerCall, i0 string) (security.Blessings, error) {
	return s.impl.BlessEc2(ctx, call, i0)
}

func (s implEc2BlesserServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implEc2BlesserServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{Ec2BlesserDesc}
}

// Ec2BlesserDesc describes the Ec2Blesser interface.
var Ec2BlesserDesc rpc.InterfaceDesc = descEc2Blesser

// descEc2Blesser hides the desc to keep godoc clean.
var descEc2Blesser = rpc.InterfaceDesc{
	Name:    "Ec2Blesser",
	PkgPath: "github.com/grailbio/base/security/identity",
	Doc:     "// Ec2Blesser returns a blessing given the provided EC2 instance identity\n// document.",
	Methods: []rpc.MethodDesc{
		{
			Name: "BlessEc2",
			Doc:  "// BlessEc2 uses the provided EC2 instance identity document in PKCS#7\n// format to return a blessing to the client.",
			InArgs: []rpc.ArgDesc{
				{Name: "pkcs7b64", Doc: ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{Name: "blessing", Doc: ``}, // security.Blessings
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
		},
	},
}

// GoogleBlesserClientMethods is the client interface
// containing GoogleBlesser methods.
//
// GoogleBlesser returns a blessing giving the provided Google ID token.
type GoogleBlesserClientMethods interface {
	BlessGoogle(_ *context.T, idToken string, _ ...rpc.CallOpt) (blessing security.Blessings, _ error)
}

// GoogleBlesserClientStub embeds GoogleBlesserClientMethods and is a
// placeholder for additional management operations.
type GoogleBlesserClientStub interface {
	GoogleBlesserClientMethods
}

// GoogleBlesserClient returns a client stub for GoogleBlesser.
func GoogleBlesserClient(name string) GoogleBlesserClientStub {
	return implGoogleBlesserClientStub{name}
}

type implGoogleBlesserClientStub struct {
	name string
}

func (c implGoogleBlesserClientStub) BlessGoogle(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 security.Blessings, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "BlessGoogle", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

// GoogleBlesserServerMethods is the interface a server writer
// implements for GoogleBlesser.
//
// GoogleBlesser returns a blessing giving the provided Google ID token.
type GoogleBlesserServerMethods interface {
	BlessGoogle(_ *context.T, _ rpc.ServerCall, idToken string) (blessing security.Blessings, _ error)
}

// GoogleBlesserServerStubMethods is the server interface containing
// GoogleBlesser methods, as expected by rpc.Server.
// There is no difference between this interface and GoogleBlesserServerMethods
// since there are no streaming methods.
type GoogleBlesserServerStubMethods GoogleBlesserServerMethods

// GoogleBlesserServerStub adds universal methods to GoogleBlesserServerStubMethods.
type GoogleBlesserServerStub interface {
	GoogleBlesserServerStubMethods
	// DescribeInterfaces the GoogleBlesser interfaces.
	Describe__() []rpc.InterfaceDesc
}

// GoogleBlesserServer returns a server stub for GoogleBlesser.
// It converts an implementation of GoogleBlesserServerMethods into
// an object that may be used by rpc.Server.
func GoogleBlesserServer(impl GoogleBlesserServerMethods) GoogleBlesserServerStub {
	stub := implGoogleBlesserServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implGoogleBlesserServerStub struct {
	impl GoogleBlesserServerMethods
	gs   *rpc.GlobState
}

func (s implGoogleBlesserServerStub) BlessGoogle(ctx *context.T, call rpc.ServerCall, i0 string) (security.Blessings, error) {
	return s.impl.BlessGoogle(ctx, call, i0)
}

func (s implGoogleBlesserServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implGoogleBlesserServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{GoogleBlesserDesc}
}

// GoogleBlesserDesc describes the GoogleBlesser interface.
var GoogleBlesserDesc rpc.InterfaceDesc = descGoogleBlesser

// descGoogleBlesser hides the desc to keep godoc clean.
var descGoogleBlesser = rpc.InterfaceDesc{
	Name:    "GoogleBlesser",
	PkgPath: "github.com/grailbio/base/security/identity",
	Doc:     "// GoogleBlesser returns a blessing giving the provided Google ID token.",
	Methods: []rpc.MethodDesc{
		{
			Name: "BlessGoogle",
			InArgs: []rpc.ArgDesc{
				{Name: "idToken", Doc: ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{Name: "blessing", Doc: ``}, // security.Blessings
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
		},
	},
}

// K8sBlesserClientMethods is the client interface
// containing K8sBlesser methods.
//
// K8sBlesser returns a blessing giving the provided Kubernetes service accountop token.
type K8sBlesserClientMethods interface {
	BlessK8s(_ *context.T, caCrt string, namespace string, token string, region string, _ ...rpc.CallOpt) (blessing security.Blessings, _ error)
}

// K8sBlesserClientStub embeds K8sBlesserClientMethods and is a
// placeholder for additional management operations.
type K8sBlesserClientStub interface {
	K8sBlesserClientMethods
}

// K8sBlesserClient returns a client stub for K8sBlesser.
func K8sBlesserClient(name string) K8sBlesserClientStub {
	return implK8sBlesserClientStub{name}
}

type implK8sBlesserClientStub struct {
	name string
}

func (c implK8sBlesserClientStub) BlessK8s(ctx *context.T, i0 string, i1 string, i2 string, i3 string, opts ...rpc.CallOpt) (o0 security.Blessings, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "BlessK8s", []interface{}{i0, i1, i2, i3}, []interface{}{&o0}, opts...)
	return
}

// K8sBlesserServerMethods is the interface a server writer
// implements for K8sBlesser.
//
// K8sBlesser returns a blessing giving the provided Kubernetes service accountop token.
type K8sBlesserServerMethods interface {
	BlessK8s(_ *context.T, _ rpc.ServerCall, caCrt string, namespace string, token string, region string) (blessing security.Blessings, _ error)
}

// K8sBlesserServerStubMethods is the server interface containing
// K8sBlesser methods, as expected by rpc.Server.
// There is no difference between this interface and K8sBlesserServerMethods
// since there are no streaming methods.
type K8sBlesserServerStubMethods K8sBlesserServerMethods

// K8sBlesserServerStub adds universal methods to K8sBlesserServerStubMethods.
type K8sBlesserServerStub interface {
	K8sBlesserServerStubMethods
	// DescribeInterfaces the K8sBlesser interfaces.
	Describe__() []rpc.InterfaceDesc
}

// K8sBlesserServer returns a server stub for K8sBlesser.
// It converts an implementation of K8sBlesserServerMethods into
// an object that may be used by rpc.Server.
func K8sBlesserServer(impl K8sBlesserServerMethods) K8sBlesserServerStub {
	stub := implK8sBlesserServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implK8sBlesserServerStub struct {
	impl K8sBlesserServerMethods
	gs   *rpc.GlobState
}

func (s implK8sBlesserServerStub) BlessK8s(ctx *context.T, call rpc.ServerCall, i0 string, i1 string, i2 string, i3 string) (security.Blessings, error) {
	return s.impl.BlessK8s(ctx, call, i0, i1, i2, i3)
}

func (s implK8sBlesserServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implK8sBlesserServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{K8sBlesserDesc}
}

// K8sBlesserDesc describes the K8sBlesser interface.
var K8sBlesserDesc rpc.InterfaceDesc = descK8sBlesser

// descK8sBlesser hides the desc to keep godoc clean.
var descK8sBlesser = rpc.InterfaceDesc{
	Name:    "K8sBlesser",
	PkgPath: "github.com/grailbio/base/security/identity",
	Doc:     "// K8sBlesser returns a blessing giving the provided Kubernetes service accountop token.",
	Methods: []rpc.MethodDesc{
		{
			Name: "BlessK8s",
			InArgs: []rpc.ArgDesc{
				{Name: "caCrt", Doc: ``},     // string
				{Name: "namespace", Doc: ``}, // string
				{Name: "token", Doc: ``},     // string
				{Name: "region", Doc: ``},    // string
			},
			OutArgs: []rpc.ArgDesc{
				{Name: "blessing", Doc: ``}, // security.Blessings
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
		},
	},
}

var initializeVDLCalled bool

// initializeVDL performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = initializeVDL()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func initializeVDL() struct{} {
	if initializeVDLCalled {
		return struct{}{}
	}
	initializeVDLCalled = true

	return struct{}{}
}