3880 lines
143 KiB
Go
3880 lines
143 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// source: sdk/plugin/pb/backend.proto
|
|
|
|
package pb
|
|
|
|
import (
|
|
context "context"
|
|
fmt "fmt"
|
|
proto "github.com/golang/protobuf/proto"
|
|
timestamp "github.com/golang/protobuf/ptypes/timestamp"
|
|
logical "github.com/hashicorp/vault/sdk/logical"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
math "math"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
type 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_4dbf1dfe0c11846b, []int{0}
|
|
}
|
|
|
|
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 (m *Empty) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Empty.Merge(m, 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
|
|
|
|
type Header struct {
|
|
Header []string `sentinel:"" protobuf:"bytes,1,rep,name=header,proto3" json:"header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Header) Reset() { *m = Header{} }
|
|
func (m *Header) String() string { return proto.CompactTextString(m) }
|
|
func (*Header) ProtoMessage() {}
|
|
func (*Header) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{1}
|
|
}
|
|
|
|
func (m *Header) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Header.Unmarshal(m, b)
|
|
}
|
|
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Header.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Header) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Header.Merge(m, src)
|
|
}
|
|
func (m *Header) XXX_Size() int {
|
|
return xxx_messageInfo_Header.Size(m)
|
|
}
|
|
func (m *Header) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Header.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Header proto.InternalMessageInfo
|
|
|
|
func (m *Header) GetHeader() []string {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ProtoError struct {
|
|
// Error type can be one of:
|
|
// ErrTypeUnknown uint32 = iota
|
|
// ErrTypeUserError
|
|
// ErrTypeInternalError
|
|
// ErrTypeCodedError
|
|
// ErrTypeStatusBadRequest
|
|
// ErrTypeUnsupportedOperation
|
|
// ErrTypeUnsupportedPath
|
|
// ErrTypeInvalidRequest
|
|
// ErrTypePermissionDenied
|
|
// ErrTypeMultiAuthzPending
|
|
ErrType uint32 `sentinel:"" protobuf:"varint,1,opt,name=err_type,json=errType,proto3" json:"err_type,omitempty"`
|
|
ErrMsg string `sentinel:"" protobuf:"bytes,2,opt,name=err_msg,json=errMsg,proto3" json:"err_msg,omitempty"`
|
|
ErrCode int64 `sentinel:"" protobuf:"varint,3,opt,name=err_code,json=errCode,proto3" json:"err_code,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ProtoError) Reset() { *m = ProtoError{} }
|
|
func (m *ProtoError) String() string { return proto.CompactTextString(m) }
|
|
func (*ProtoError) ProtoMessage() {}
|
|
func (*ProtoError) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{2}
|
|
}
|
|
|
|
func (m *ProtoError) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ProtoError.Unmarshal(m, b)
|
|
}
|
|
func (m *ProtoError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ProtoError.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ProtoError) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ProtoError.Merge(m, src)
|
|
}
|
|
func (m *ProtoError) XXX_Size() int {
|
|
return xxx_messageInfo_ProtoError.Size(m)
|
|
}
|
|
func (m *ProtoError) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ProtoError.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ProtoError proto.InternalMessageInfo
|
|
|
|
func (m *ProtoError) GetErrType() uint32 {
|
|
if m != nil {
|
|
return m.ErrType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ProtoError) GetErrMsg() string {
|
|
if m != nil {
|
|
return m.ErrMsg
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ProtoError) GetErrCode() int64 {
|
|
if m != nil {
|
|
return m.ErrCode
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Paths is the structure of special paths that is used for SpecialPaths.
|
|
type Paths struct {
|
|
// Root are the paths that require a root token to access
|
|
Root []string `sentinel:"" protobuf:"bytes,1,rep,name=root,proto3" json:"root,omitempty"`
|
|
// Unauthenticated are the paths that can be accessed without any auth.
|
|
Unauthenticated []string `sentinel:"" protobuf:"bytes,2,rep,name=unauthenticated,proto3" json:"unauthenticated,omitempty"`
|
|
// LocalStorage are paths (prefixes) that are local to this instance; this
|
|
// indicates that these paths should not be replicated
|
|
LocalStorage []string `sentinel:"" protobuf:"bytes,3,rep,name=local_storage,json=localStorage,proto3" json:"local_storage,omitempty"`
|
|
// SealWrapStorage are storage paths that, when using a capable seal,
|
|
// should be seal wrapped with extra encryption. It is exact matching
|
|
// unless it ends with '/' in which case it will be treated as a prefix.
|
|
SealWrapStorage []string `sentinel:"" protobuf:"bytes,4,rep,name=seal_wrap_storage,json=sealWrapStorage,proto3" json:"seal_wrap_storage,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Paths) Reset() { *m = Paths{} }
|
|
func (m *Paths) String() string { return proto.CompactTextString(m) }
|
|
func (*Paths) ProtoMessage() {}
|
|
func (*Paths) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{3}
|
|
}
|
|
|
|
func (m *Paths) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Paths.Unmarshal(m, b)
|
|
}
|
|
func (m *Paths) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Paths.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Paths) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Paths.Merge(m, src)
|
|
}
|
|
func (m *Paths) XXX_Size() int {
|
|
return xxx_messageInfo_Paths.Size(m)
|
|
}
|
|
func (m *Paths) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Paths.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Paths proto.InternalMessageInfo
|
|
|
|
func (m *Paths) GetRoot() []string {
|
|
if m != nil {
|
|
return m.Root
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Paths) GetUnauthenticated() []string {
|
|
if m != nil {
|
|
return m.Unauthenticated
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Paths) GetLocalStorage() []string {
|
|
if m != nil {
|
|
return m.LocalStorage
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Paths) GetSealWrapStorage() []string {
|
|
if m != nil {
|
|
return m.SealWrapStorage
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Request struct {
|
|
// ID is the uuid associated with each request
|
|
ID string `sentinel:"" protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
// If set, the name given to the replication secondary where this request
|
|
// originated
|
|
ReplicationCluster string `sentinel:"" protobuf:"bytes,2,opt,name=ReplicationCluster,proto3" json:"ReplicationCluster,omitempty"`
|
|
// Operation is the requested operation type
|
|
Operation string `sentinel:"" protobuf:"bytes,3,opt,name=operation,proto3" json:"operation,omitempty"`
|
|
// Path is the part of the request path not consumed by the
|
|
// routing. As an example, if the original request path is "prod/aws/foo"
|
|
// and the AWS logical backend is mounted at "prod/aws/", then the
|
|
// final path is "foo" since the mount prefix is trimmed.
|
|
Path string `sentinel:"" protobuf:"bytes,4,opt,name=path,proto3" json:"path,omitempty"`
|
|
// Request data is a JSON object that must have keys with string type.
|
|
Data string `sentinel:"" protobuf:"bytes,5,opt,name=data,proto3" json:"data,omitempty"`
|
|
// Secret will be non-nil only for Revoke and Renew operations
|
|
// to represent the secret that was returned prior.
|
|
Secret *Secret `sentinel:"" protobuf:"bytes,6,opt,name=secret,proto3" json:"secret,omitempty"`
|
|
// Auth will be non-nil only for Renew operations
|
|
// to represent the auth that was returned prior.
|
|
Auth *Auth `sentinel:"" protobuf:"bytes,7,opt,name=auth,proto3" json:"auth,omitempty"`
|
|
// Headers will contain the http headers from the request. This value will
|
|
// be used in the audit broker to ensure we are auditing only the allowed
|
|
// headers.
|
|
Headers map[string]*Header `sentinel:"" protobuf:"bytes,8,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
// ClientToken is provided to the core so that the identity
|
|
// can be verified and ACLs applied. This value is passed
|
|
// through to the logical backends but after being salted and
|
|
// hashed.
|
|
ClientToken string `sentinel:"" protobuf:"bytes,9,opt,name=client_token,json=clientToken,proto3" json:"client_token,omitempty"`
|
|
// ClientTokenAccessor is provided to the core so that the it can get
|
|
// logged as part of request audit logging.
|
|
ClientTokenAccessor string `sentinel:"" protobuf:"bytes,10,opt,name=client_token_accessor,json=clientTokenAccessor,proto3" json:"client_token_accessor,omitempty"`
|
|
// DisplayName is provided to the logical backend to help associate
|
|
// dynamic secrets with the source entity. This is not a sensitive
|
|
// name, but is useful for operators.
|
|
DisplayName string `sentinel:"" protobuf:"bytes,11,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
|
|
// MountPoint is provided so that a logical backend can generate
|
|
// paths relative to itself. The `Path` is effectively the client
|
|
// request path with the MountPoint trimmed off.
|
|
MountPoint string `sentinel:"" protobuf:"bytes,12,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
|
|
// MountType is provided so that a logical backend can make decisions
|
|
// based on the specific mount type (e.g., if a mount type has different
|
|
// aliases, generating different defaults depending on the alias)
|
|
MountType string `sentinel:"" protobuf:"bytes,13,opt,name=mount_type,json=mountType,proto3" json:"mount_type,omitempty"`
|
|
// MountAccessor is provided so that identities returned by the authentication
|
|
// backends can be tied to the mount it belongs to.
|
|
MountAccessor string `sentinel:"" protobuf:"bytes,14,opt,name=mount_accessor,json=mountAccessor,proto3" json:"mount_accessor,omitempty"`
|
|
// WrapInfo contains requested response wrapping parameters
|
|
WrapInfo *RequestWrapInfo `sentinel:"" protobuf:"bytes,15,opt,name=wrap_info,json=wrapInfo,proto3" json:"wrap_info,omitempty"`
|
|
// ClientTokenRemainingUses represents the allowed number of uses left on the
|
|
// token supplied
|
|
ClientTokenRemainingUses int64 `sentinel:"" protobuf:"varint,16,opt,name=client_token_remaining_uses,json=clientTokenRemainingUses,proto3" json:"client_token_remaining_uses,omitempty"`
|
|
// EntityID is the identity of the caller extracted out of the token used
|
|
// to make this request
|
|
EntityID string `sentinel:"" protobuf:"bytes,17,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
|
|
// PolicyOverride indicates that the requestor wishes to override
|
|
// soft-mandatory Sentinel policies
|
|
PolicyOverride bool `sentinel:"" protobuf:"varint,18,opt,name=policy_override,json=policyOverride,proto3" json:"policy_override,omitempty"`
|
|
// Whether the request is unauthenticated, as in, had no client token
|
|
// attached. Useful in some situations where the client token is not made
|
|
// accessible.
|
|
Unauthenticated bool `sentinel:"" protobuf:"varint,19,opt,name=unauthenticated,proto3" json:"unauthenticated,omitempty"`
|
|
// Connection will be non-nil only for credential providers to
|
|
// inspect the connection information and potentially use it for
|
|
// authentication/protection.
|
|
Connection *Connection `sentinel:"" protobuf:"bytes,20,opt,name=connection,proto3" json:"connection,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Request) Reset() { *m = Request{} }
|
|
func (m *Request) String() string { return proto.CompactTextString(m) }
|
|
func (*Request) ProtoMessage() {}
|
|
func (*Request) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{4}
|
|
}
|
|
|
|
func (m *Request) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Request.Unmarshal(m, b)
|
|
}
|
|
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Request.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Request) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Request.Merge(m, src)
|
|
}
|
|
func (m *Request) XXX_Size() int {
|
|
return xxx_messageInfo_Request.Size(m)
|
|
}
|
|
func (m *Request) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Request.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Request proto.InternalMessageInfo
|
|
|
|
func (m *Request) GetID() string {
|
|
if m != nil {
|
|
return m.ID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetReplicationCluster() string {
|
|
if m != nil {
|
|
return m.ReplicationCluster
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetOperation() string {
|
|
if m != nil {
|
|
return m.Operation
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetPath() string {
|
|
if m != nil {
|
|
return m.Path
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetData() string {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetSecret() *Secret {
|
|
if m != nil {
|
|
return m.Secret
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Request) GetAuth() *Auth {
|
|
if m != nil {
|
|
return m.Auth
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Request) GetHeaders() map[string]*Header {
|
|
if m != nil {
|
|
return m.Headers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Request) GetClientToken() string {
|
|
if m != nil {
|
|
return m.ClientToken
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetClientTokenAccessor() string {
|
|
if m != nil {
|
|
return m.ClientTokenAccessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetDisplayName() string {
|
|
if m != nil {
|
|
return m.DisplayName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetMountPoint() string {
|
|
if m != nil {
|
|
return m.MountPoint
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetMountType() string {
|
|
if m != nil {
|
|
return m.MountType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetMountAccessor() string {
|
|
if m != nil {
|
|
return m.MountAccessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetWrapInfo() *RequestWrapInfo {
|
|
if m != nil {
|
|
return m.WrapInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Request) GetClientTokenRemainingUses() int64 {
|
|
if m != nil {
|
|
return m.ClientTokenRemainingUses
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Request) GetEntityID() string {
|
|
if m != nil {
|
|
return m.EntityID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Request) GetPolicyOverride() bool {
|
|
if m != nil {
|
|
return m.PolicyOverride
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Request) GetUnauthenticated() bool {
|
|
if m != nil {
|
|
return m.Unauthenticated
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Request) GetConnection() *Connection {
|
|
if m != nil {
|
|
return m.Connection
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Auth struct {
|
|
LeaseOptions *LeaseOptions `sentinel:"" protobuf:"bytes,1,opt,name=lease_options,json=leaseOptions,proto3" json:"lease_options,omitempty"`
|
|
// InternalData is a JSON object that is stored with the auth struct.
|
|
// This will be sent back during a Renew/Revoke for storing internal data
|
|
// used for those operations.
|
|
InternalData string `sentinel:"" protobuf:"bytes,2,opt,name=internal_data,json=internalData,proto3" json:"internal_data,omitempty"`
|
|
// DisplayName is a non-security sensitive identifier that is
|
|
// applicable to this Auth. It is used for logging and prefixing
|
|
// of dynamic secrets. For example, DisplayName may be "armon" for
|
|
// the github credential backend. If the client token is used to
|
|
// generate a SQL credential, the user may be "github-armon-uuid".
|
|
// This is to help identify the source without using audit tables.
|
|
DisplayName string `sentinel:"" protobuf:"bytes,3,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
|
|
// Policies is the list of policies that the authenticated user
|
|
// is associated with.
|
|
Policies []string `sentinel:"" protobuf:"bytes,4,rep,name=policies,proto3" json:"policies,omitempty"`
|
|
// Metadata is used to attach arbitrary string-type metadata to
|
|
// an authenticated user. This metadata will be outputted into the
|
|
// audit log.
|
|
Metadata map[string]string `sentinel:"" protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
// ClientToken is the token that is generated for the authentication.
|
|
// This will be filled in by Vault core when an auth structure is
|
|
// returned. Setting this manually will have no effect.
|
|
ClientToken string `sentinel:"" protobuf:"bytes,6,opt,name=client_token,json=clientToken,proto3" json:"client_token,omitempty"`
|
|
// Accessor is the identifier for the ClientToken. This can be used
|
|
// to perform management functionalities (especially revocation) when
|
|
// ClientToken in the audit logs are obfuscated. Accessor can be used
|
|
// to revoke a ClientToken and to lookup the capabilities of the ClientToken,
|
|
// both without actually knowing the ClientToken.
|
|
Accessor string `sentinel:"" protobuf:"bytes,7,opt,name=accessor,proto3" json:"accessor,omitempty"`
|
|
// Period indicates that the token generated using this Auth object
|
|
// should never expire. The token should be renewed within the duration
|
|
// specified by this period.
|
|
Period int64 `sentinel:"" protobuf:"varint,8,opt,name=period,proto3" json:"period,omitempty"`
|
|
// Number of allowed uses of the issued token
|
|
NumUses int64 `sentinel:"" protobuf:"varint,9,opt,name=num_uses,json=numUses,proto3" json:"num_uses,omitempty"`
|
|
// EntityID is the identifier of the entity in identity store to which the
|
|
// identity of the authenticating client belongs to.
|
|
EntityID string `sentinel:"" protobuf:"bytes,10,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
|
|
// Alias is the information about the authenticated client returned by
|
|
// the auth backend
|
|
Alias *logical.Alias `sentinel:"" protobuf:"bytes,11,opt,name=alias,proto3" json:"alias,omitempty"`
|
|
// GroupAliases are the informational mappings of external groups which an
|
|
// authenticated user belongs to. This is used to check if there are
|
|
// mappings groups for the group aliases in identity store. For all the
|
|
// matching groups, the entity ID of the user will be added.
|
|
GroupAliases []*logical.Alias `sentinel:"" protobuf:"bytes,12,rep,name=group_aliases,json=groupAliases,proto3" json:"group_aliases,omitempty"`
|
|
// If set, restricts usage of the certificates to client IPs falling within
|
|
// the range of the specified CIDR(s).
|
|
BoundCIDRs []string `sentinel:"" protobuf:"bytes,13,rep,name=bound_cidrs,json=boundCidrs,proto3" json:"bound_cidrs,omitempty"`
|
|
// TokenPolicies and IdentityPolicies break down the list in Policies to
|
|
// help determine where a policy was sourced
|
|
TokenPolicies []string `sentinel:"" protobuf:"bytes,14,rep,name=token_policies,json=tokenPolicies,proto3" json:"token_policies,omitempty"`
|
|
IdentityPolicies []string `sentinel:"" protobuf:"bytes,15,rep,name=identity_policies,json=identityPolicies,proto3" json:"identity_policies,omitempty"`
|
|
// Explicit maximum lifetime for the token. Unlike normal TTLs, the maximum
|
|
// TTL is a hard limit and cannot be exceeded, also counts for periodic tokens.
|
|
ExplicitMaxTTL int64 `sentinel:"" protobuf:"varint,16,opt,name=explicit_max_ttl,json=explicitMaxTtl,proto3" json:"explicit_max_ttl,omitempty"`
|
|
// TokenType is the type of token being requested
|
|
TokenType uint32 `sentinel:"" protobuf:"varint,17,opt,name=token_type,json=tokenType,proto3" json:"token_type,omitempty"`
|
|
// Whether the default policy should be added automatically by core
|
|
NoDefaultPolicy bool `sentinel:"" protobuf:"varint,18,opt,name=no_default_policy,json=noDefaultPolicy,proto3" json:"no_default_policy,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Auth) Reset() { *m = Auth{} }
|
|
func (m *Auth) String() string { return proto.CompactTextString(m) }
|
|
func (*Auth) ProtoMessage() {}
|
|
func (*Auth) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{5}
|
|
}
|
|
|
|
func (m *Auth) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Auth.Unmarshal(m, b)
|
|
}
|
|
func (m *Auth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Auth.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Auth) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Auth.Merge(m, src)
|
|
}
|
|
func (m *Auth) XXX_Size() int {
|
|
return xxx_messageInfo_Auth.Size(m)
|
|
}
|
|
func (m *Auth) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Auth.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Auth proto.InternalMessageInfo
|
|
|
|
func (m *Auth) GetLeaseOptions() *LeaseOptions {
|
|
if m != nil {
|
|
return m.LeaseOptions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetInternalData() string {
|
|
if m != nil {
|
|
return m.InternalData
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Auth) GetDisplayName() string {
|
|
if m != nil {
|
|
return m.DisplayName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Auth) GetPolicies() []string {
|
|
if m != nil {
|
|
return m.Policies
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetMetadata() map[string]string {
|
|
if m != nil {
|
|
return m.Metadata
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetClientToken() string {
|
|
if m != nil {
|
|
return m.ClientToken
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Auth) GetAccessor() string {
|
|
if m != nil {
|
|
return m.Accessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Auth) GetPeriod() int64 {
|
|
if m != nil {
|
|
return m.Period
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Auth) GetNumUses() int64 {
|
|
if m != nil {
|
|
return m.NumUses
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Auth) GetEntityID() string {
|
|
if m != nil {
|
|
return m.EntityID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Auth) GetAlias() *logical.Alias {
|
|
if m != nil {
|
|
return m.Alias
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetGroupAliases() []*logical.Alias {
|
|
if m != nil {
|
|
return m.GroupAliases
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetBoundCIDRs() []string {
|
|
if m != nil {
|
|
return m.BoundCIDRs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetTokenPolicies() []string {
|
|
if m != nil {
|
|
return m.TokenPolicies
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetIdentityPolicies() []string {
|
|
if m != nil {
|
|
return m.IdentityPolicies
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Auth) GetExplicitMaxTTL() int64 {
|
|
if m != nil {
|
|
return m.ExplicitMaxTTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Auth) GetTokenType() uint32 {
|
|
if m != nil {
|
|
return m.TokenType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Auth) GetNoDefaultPolicy() bool {
|
|
if m != nil {
|
|
return m.NoDefaultPolicy
|
|
}
|
|
return false
|
|
}
|
|
|
|
type TokenEntry struct {
|
|
ID string `sentinel:"" protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
Accessor string `sentinel:"" protobuf:"bytes,2,opt,name=accessor,proto3" json:"accessor,omitempty"`
|
|
Parent string `sentinel:"" protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"`
|
|
Policies []string `sentinel:"" protobuf:"bytes,4,rep,name=policies,proto3" json:"policies,omitempty"`
|
|
Path string `sentinel:"" protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
|
|
Meta map[string]string `sentinel:"" protobuf:"bytes,6,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
DisplayName string `sentinel:"" protobuf:"bytes,7,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
|
|
NumUses int64 `sentinel:"" protobuf:"varint,8,opt,name=num_uses,json=numUses,proto3" json:"num_uses,omitempty"`
|
|
CreationTime int64 `sentinel:"" protobuf:"varint,9,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
|
|
TTL int64 `sentinel:"" protobuf:"varint,10,opt,name=ttl,proto3" json:"ttl,omitempty"`
|
|
ExplicitMaxTTL int64 `sentinel:"" protobuf:"varint,11,opt,name=explicit_max_ttl,json=explicitMaxTtl,proto3" json:"explicit_max_ttl,omitempty"`
|
|
Role string `sentinel:"" protobuf:"bytes,12,opt,name=role,proto3" json:"role,omitempty"`
|
|
Period int64 `sentinel:"" protobuf:"varint,13,opt,name=period,proto3" json:"period,omitempty"`
|
|
EntityID string `sentinel:"" protobuf:"bytes,14,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
|
|
BoundCIDRs []string `sentinel:"" protobuf:"bytes,15,rep,name=bound_cidrs,json=boundCidrs,proto3" json:"bound_cidrs,omitempty"`
|
|
NamespaceID string `sentinel:"" protobuf:"bytes,16,opt,name=namespace_id,json=namespaceID,proto3" json:"namespace_id,omitempty"`
|
|
CubbyholeID string `sentinel:"" protobuf:"bytes,17,opt,name=cubbyhole_id,json=cubbyholeId,proto3" json:"cubbyhole_id,omitempty"`
|
|
Type uint32 `sentinel:"" protobuf:"varint,18,opt,name=type,proto3" json:"type,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *TokenEntry) Reset() { *m = TokenEntry{} }
|
|
func (m *TokenEntry) String() string { return proto.CompactTextString(m) }
|
|
func (*TokenEntry) ProtoMessage() {}
|
|
func (*TokenEntry) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{6}
|
|
}
|
|
|
|
func (m *TokenEntry) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_TokenEntry.Unmarshal(m, b)
|
|
}
|
|
func (m *TokenEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_TokenEntry.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *TokenEntry) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TokenEntry.Merge(m, src)
|
|
}
|
|
func (m *TokenEntry) XXX_Size() int {
|
|
return xxx_messageInfo_TokenEntry.Size(m)
|
|
}
|
|
func (m *TokenEntry) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TokenEntry.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TokenEntry proto.InternalMessageInfo
|
|
|
|
func (m *TokenEntry) GetID() string {
|
|
if m != nil {
|
|
return m.ID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetAccessor() string {
|
|
if m != nil {
|
|
return m.Accessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetParent() string {
|
|
if m != nil {
|
|
return m.Parent
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetPolicies() []string {
|
|
if m != nil {
|
|
return m.Policies
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TokenEntry) GetPath() string {
|
|
if m != nil {
|
|
return m.Path
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetMeta() map[string]string {
|
|
if m != nil {
|
|
return m.Meta
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TokenEntry) GetDisplayName() string {
|
|
if m != nil {
|
|
return m.DisplayName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetNumUses() int64 {
|
|
if m != nil {
|
|
return m.NumUses
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TokenEntry) GetCreationTime() int64 {
|
|
if m != nil {
|
|
return m.CreationTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TokenEntry) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TokenEntry) GetExplicitMaxTTL() int64 {
|
|
if m != nil {
|
|
return m.ExplicitMaxTTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TokenEntry) GetRole() string {
|
|
if m != nil {
|
|
return m.Role
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetPeriod() int64 {
|
|
if m != nil {
|
|
return m.Period
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *TokenEntry) GetEntityID() string {
|
|
if m != nil {
|
|
return m.EntityID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetBoundCIDRs() []string {
|
|
if m != nil {
|
|
return m.BoundCIDRs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TokenEntry) GetNamespaceID() string {
|
|
if m != nil {
|
|
return m.NamespaceID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetCubbyholeID() string {
|
|
if m != nil {
|
|
return m.CubbyholeID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TokenEntry) GetType() uint32 {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LeaseOptions struct {
|
|
TTL int64 `sentinel:"" protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
|
|
Renewable bool `sentinel:"" protobuf:"varint,2,opt,name=renewable,proto3" json:"renewable,omitempty"`
|
|
Increment int64 `sentinel:"" protobuf:"varint,3,opt,name=increment,proto3" json:"increment,omitempty"`
|
|
IssueTime *timestamp.Timestamp `sentinel:"" protobuf:"bytes,4,opt,name=issue_time,json=issueTime,proto3" json:"issue_time,omitempty"`
|
|
MaxTTL int64 `sentinel:"" protobuf:"varint,5,opt,name=MaxTTL,proto3" json:"MaxTTL,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *LeaseOptions) Reset() { *m = LeaseOptions{} }
|
|
func (m *LeaseOptions) String() string { return proto.CompactTextString(m) }
|
|
func (*LeaseOptions) ProtoMessage() {}
|
|
func (*LeaseOptions) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{7}
|
|
}
|
|
|
|
func (m *LeaseOptions) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_LeaseOptions.Unmarshal(m, b)
|
|
}
|
|
func (m *LeaseOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_LeaseOptions.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *LeaseOptions) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LeaseOptions.Merge(m, src)
|
|
}
|
|
func (m *LeaseOptions) XXX_Size() int {
|
|
return xxx_messageInfo_LeaseOptions.Size(m)
|
|
}
|
|
func (m *LeaseOptions) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LeaseOptions.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LeaseOptions proto.InternalMessageInfo
|
|
|
|
func (m *LeaseOptions) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *LeaseOptions) GetRenewable() bool {
|
|
if m != nil {
|
|
return m.Renewable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *LeaseOptions) GetIncrement() int64 {
|
|
if m != nil {
|
|
return m.Increment
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *LeaseOptions) GetIssueTime() *timestamp.Timestamp {
|
|
if m != nil {
|
|
return m.IssueTime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *LeaseOptions) GetMaxTTL() int64 {
|
|
if m != nil {
|
|
return m.MaxTTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Secret struct {
|
|
LeaseOptions *LeaseOptions `sentinel:"" protobuf:"bytes,1,opt,name=lease_options,json=leaseOptions,proto3" json:"lease_options,omitempty"`
|
|
// InternalData is a JSON object that is stored with the secret.
|
|
// This will be sent back during a Renew/Revoke for storing internal data
|
|
// used for those operations.
|
|
InternalData string `sentinel:"" protobuf:"bytes,2,opt,name=internal_data,json=internalData,proto3" json:"internal_data,omitempty"`
|
|
// LeaseID is the ID returned to the user to manage this secret.
|
|
// This is generated by Vault core. Any set value will be ignored.
|
|
// For requests, this will always be blank.
|
|
LeaseID string `sentinel:"" protobuf:"bytes,3,opt,name=lease_id,json=leaseId,proto3" json:"lease_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Secret) Reset() { *m = Secret{} }
|
|
func (m *Secret) String() string { return proto.CompactTextString(m) }
|
|
func (*Secret) ProtoMessage() {}
|
|
func (*Secret) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{8}
|
|
}
|
|
|
|
func (m *Secret) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Secret.Unmarshal(m, b)
|
|
}
|
|
func (m *Secret) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Secret.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Secret) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Secret.Merge(m, src)
|
|
}
|
|
func (m *Secret) XXX_Size() int {
|
|
return xxx_messageInfo_Secret.Size(m)
|
|
}
|
|
func (m *Secret) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Secret.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Secret proto.InternalMessageInfo
|
|
|
|
func (m *Secret) GetLeaseOptions() *LeaseOptions {
|
|
if m != nil {
|
|
return m.LeaseOptions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Secret) GetInternalData() string {
|
|
if m != nil {
|
|
return m.InternalData
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Secret) GetLeaseID() string {
|
|
if m != nil {
|
|
return m.LeaseID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Response struct {
|
|
// Secret, if not nil, denotes that this response represents a secret.
|
|
Secret *Secret `sentinel:"" protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
|
|
// Auth, if not nil, contains the authentication information for
|
|
// this response. This is only checked and means something for
|
|
// credential backends.
|
|
Auth *Auth `sentinel:"" protobuf:"bytes,2,opt,name=auth,proto3" json:"auth,omitempty"`
|
|
// Response data is a JSON object that must have string keys. For
|
|
// secrets, this data is sent down to the user as-is. To store internal
|
|
// data that you don't want the user to see, store it in
|
|
// Secret.InternalData.
|
|
Data string `sentinel:"" protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
|
|
// Redirect is an HTTP URL to redirect to for further authentication.
|
|
// This is only valid for credential backends. This will be blanked
|
|
// for any logical backend and ignored.
|
|
Redirect string `sentinel:"" protobuf:"bytes,4,opt,name=redirect,proto3" json:"redirect,omitempty"`
|
|
// Warnings allow operations or backends to return warnings in response
|
|
// to user actions without failing the action outright.
|
|
Warnings []string `sentinel:"" protobuf:"bytes,5,rep,name=warnings,proto3" json:"warnings,omitempty"`
|
|
// Information for wrapping the response in a cubbyhole
|
|
WrapInfo *ResponseWrapInfo `sentinel:"" protobuf:"bytes,6,opt,name=wrap_info,json=wrapInfo,proto3" json:"wrap_info,omitempty"`
|
|
// Headers will contain the http headers from the response. This value will
|
|
// be used in the audit broker to ensure we are auditing only the allowed
|
|
// headers.
|
|
Headers map[string]*Header `sentinel:"" protobuf:"bytes,7,rep,name=headers,proto3" json:"headers,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 *Response) Reset() { *m = Response{} }
|
|
func (m *Response) String() string { return proto.CompactTextString(m) }
|
|
func (*Response) ProtoMessage() {}
|
|
func (*Response) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{9}
|
|
}
|
|
|
|
func (m *Response) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Response.Unmarshal(m, b)
|
|
}
|
|
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Response.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Response) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Response.Merge(m, src)
|
|
}
|
|
func (m *Response) XXX_Size() int {
|
|
return xxx_messageInfo_Response.Size(m)
|
|
}
|
|
func (m *Response) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Response.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Response proto.InternalMessageInfo
|
|
|
|
func (m *Response) GetSecret() *Secret {
|
|
if m != nil {
|
|
return m.Secret
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Response) GetAuth() *Auth {
|
|
if m != nil {
|
|
return m.Auth
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Response) GetData() string {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Response) GetRedirect() string {
|
|
if m != nil {
|
|
return m.Redirect
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Response) GetWarnings() []string {
|
|
if m != nil {
|
|
return m.Warnings
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Response) GetWrapInfo() *ResponseWrapInfo {
|
|
if m != nil {
|
|
return m.WrapInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Response) GetHeaders() map[string]*Header {
|
|
if m != nil {
|
|
return m.Headers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ResponseWrapInfo struct {
|
|
// Setting to non-zero specifies that the response should be wrapped.
|
|
// Specifies the desired TTL of the wrapping token.
|
|
TTL int64 `sentinel:"" protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
|
|
// The token containing the wrapped response
|
|
Token string `sentinel:"" protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
|
|
// The token accessor for the wrapped response token
|
|
Accessor string `sentinel:"" protobuf:"bytes,3,opt,name=accessor,proto3" json:"accessor,omitempty"`
|
|
// The creation time. This can be used with the TTL to figure out an
|
|
// expected expiration.
|
|
CreationTime *timestamp.Timestamp `sentinel:"" protobuf:"bytes,4,opt,name=creation_time,json=creationTime,proto3" json:"creation_time,omitempty"`
|
|
// If the contained response is the output of a token creation call, the
|
|
// created token's accessor will be accessible here
|
|
WrappedAccessor string `sentinel:"" protobuf:"bytes,5,opt,name=wrapped_accessor,json=wrappedAccessor,proto3" json:"wrapped_accessor,omitempty"`
|
|
// WrappedEntityID is the entity identifier of the caller who initiated the
|
|
// wrapping request
|
|
WrappedEntityID string `sentinel:"" protobuf:"bytes,6,opt,name=wrapped_entity_id,json=wrappedEntityID,proto3" json:"wrapped_entity_id,omitempty"`
|
|
// The format to use. This doesn't get returned, it's only internal.
|
|
Format string `sentinel:"" protobuf:"bytes,7,opt,name=format,proto3" json:"format,omitempty"`
|
|
// CreationPath is the original request path that was used to create
|
|
// the wrapped response.
|
|
CreationPath string `sentinel:"" protobuf:"bytes,8,opt,name=creation_path,json=creationPath,proto3" json:"creation_path,omitempty"`
|
|
// Controls seal wrapping behavior downstream for specific use cases
|
|
SealWrap bool `sentinel:"" protobuf:"varint,9,opt,name=seal_wrap,json=sealWrap,proto3" json:"seal_wrap,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) Reset() { *m = ResponseWrapInfo{} }
|
|
func (m *ResponseWrapInfo) String() string { return proto.CompactTextString(m) }
|
|
func (*ResponseWrapInfo) ProtoMessage() {}
|
|
func (*ResponseWrapInfo) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{10}
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ResponseWrapInfo.Unmarshal(m, b)
|
|
}
|
|
func (m *ResponseWrapInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ResponseWrapInfo.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ResponseWrapInfo) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ResponseWrapInfo.Merge(m, src)
|
|
}
|
|
func (m *ResponseWrapInfo) XXX_Size() int {
|
|
return xxx_messageInfo_ResponseWrapInfo.Size(m)
|
|
}
|
|
func (m *ResponseWrapInfo) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ResponseWrapInfo.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ResponseWrapInfo proto.InternalMessageInfo
|
|
|
|
func (m *ResponseWrapInfo) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetToken() string {
|
|
if m != nil {
|
|
return m.Token
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetAccessor() string {
|
|
if m != nil {
|
|
return m.Accessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetCreationTime() *timestamp.Timestamp {
|
|
if m != nil {
|
|
return m.CreationTime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetWrappedAccessor() string {
|
|
if m != nil {
|
|
return m.WrappedAccessor
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetWrappedEntityID() string {
|
|
if m != nil {
|
|
return m.WrappedEntityID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetFormat() string {
|
|
if m != nil {
|
|
return m.Format
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetCreationPath() string {
|
|
if m != nil {
|
|
return m.CreationPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapInfo) GetSealWrap() bool {
|
|
if m != nil {
|
|
return m.SealWrap
|
|
}
|
|
return false
|
|
}
|
|
|
|
type RequestWrapInfo struct {
|
|
// Setting to non-zero specifies that the response should be wrapped.
|
|
// Specifies the desired TTL of the wrapping token.
|
|
TTL int64 `sentinel:"" protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
|
|
// The format to use for the wrapped response; if not specified it's a bare
|
|
// token
|
|
Format string `sentinel:"" protobuf:"bytes,2,opt,name=format,proto3" json:"format,omitempty"`
|
|
// A flag to conforming backends that data for a given request should be
|
|
// seal wrapped
|
|
SealWrap bool `sentinel:"" protobuf:"varint,3,opt,name=seal_wrap,json=sealWrap,proto3" json:"seal_wrap,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *RequestWrapInfo) Reset() { *m = RequestWrapInfo{} }
|
|
func (m *RequestWrapInfo) String() string { return proto.CompactTextString(m) }
|
|
func (*RequestWrapInfo) ProtoMessage() {}
|
|
func (*RequestWrapInfo) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{11}
|
|
}
|
|
|
|
func (m *RequestWrapInfo) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_RequestWrapInfo.Unmarshal(m, b)
|
|
}
|
|
func (m *RequestWrapInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_RequestWrapInfo.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *RequestWrapInfo) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_RequestWrapInfo.Merge(m, src)
|
|
}
|
|
func (m *RequestWrapInfo) XXX_Size() int {
|
|
return xxx_messageInfo_RequestWrapInfo.Size(m)
|
|
}
|
|
func (m *RequestWrapInfo) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_RequestWrapInfo.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_RequestWrapInfo proto.InternalMessageInfo
|
|
|
|
func (m *RequestWrapInfo) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *RequestWrapInfo) GetFormat() string {
|
|
if m != nil {
|
|
return m.Format
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *RequestWrapInfo) GetSealWrap() bool {
|
|
if m != nil {
|
|
return m.SealWrap
|
|
}
|
|
return false
|
|
}
|
|
|
|
// HandleRequestArgs is the args for HandleRequest method.
|
|
type HandleRequestArgs struct {
|
|
StorageID uint32 `sentinel:"" protobuf:"varint,1,opt,name=storage_id,json=storageId,proto3" json:"storage_id,omitempty"`
|
|
Request *Request `sentinel:"" protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *HandleRequestArgs) Reset() { *m = HandleRequestArgs{} }
|
|
func (m *HandleRequestArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*HandleRequestArgs) ProtoMessage() {}
|
|
func (*HandleRequestArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{12}
|
|
}
|
|
|
|
func (m *HandleRequestArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_HandleRequestArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *HandleRequestArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_HandleRequestArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *HandleRequestArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_HandleRequestArgs.Merge(m, src)
|
|
}
|
|
func (m *HandleRequestArgs) XXX_Size() int {
|
|
return xxx_messageInfo_HandleRequestArgs.Size(m)
|
|
}
|
|
func (m *HandleRequestArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_HandleRequestArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_HandleRequestArgs proto.InternalMessageInfo
|
|
|
|
func (m *HandleRequestArgs) GetStorageID() uint32 {
|
|
if m != nil {
|
|
return m.StorageID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *HandleRequestArgs) GetRequest() *Request {
|
|
if m != nil {
|
|
return m.Request
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HandleRequestReply is the reply for HandleRequest method.
|
|
type HandleRequestReply struct {
|
|
Response *Response `sentinel:"" protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
|
|
Err *ProtoError `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *HandleRequestReply) Reset() { *m = HandleRequestReply{} }
|
|
func (m *HandleRequestReply) String() string { return proto.CompactTextString(m) }
|
|
func (*HandleRequestReply) ProtoMessage() {}
|
|
func (*HandleRequestReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{13}
|
|
}
|
|
|
|
func (m *HandleRequestReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_HandleRequestReply.Unmarshal(m, b)
|
|
}
|
|
func (m *HandleRequestReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_HandleRequestReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *HandleRequestReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_HandleRequestReply.Merge(m, src)
|
|
}
|
|
func (m *HandleRequestReply) XXX_Size() int {
|
|
return xxx_messageInfo_HandleRequestReply.Size(m)
|
|
}
|
|
func (m *HandleRequestReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_HandleRequestReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_HandleRequestReply proto.InternalMessageInfo
|
|
|
|
func (m *HandleRequestReply) GetResponse() *Response {
|
|
if m != nil {
|
|
return m.Response
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *HandleRequestReply) GetErr() *ProtoError {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// InitializeArgs is the args for Initialize method.
|
|
type InitializeArgs struct {
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *InitializeArgs) Reset() { *m = InitializeArgs{} }
|
|
func (m *InitializeArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*InitializeArgs) ProtoMessage() {}
|
|
func (*InitializeArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{14}
|
|
}
|
|
|
|
func (m *InitializeArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_InitializeArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *InitializeArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_InitializeArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *InitializeArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_InitializeArgs.Merge(m, src)
|
|
}
|
|
func (m *InitializeArgs) XXX_Size() int {
|
|
return xxx_messageInfo_InitializeArgs.Size(m)
|
|
}
|
|
func (m *InitializeArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_InitializeArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_InitializeArgs proto.InternalMessageInfo
|
|
|
|
// InitializeReply is the reply for Initialize method.
|
|
type InitializeReply struct {
|
|
Err *ProtoError `sentinel:"" protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *InitializeReply) Reset() { *m = InitializeReply{} }
|
|
func (m *InitializeReply) String() string { return proto.CompactTextString(m) }
|
|
func (*InitializeReply) ProtoMessage() {}
|
|
func (*InitializeReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{15}
|
|
}
|
|
|
|
func (m *InitializeReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_InitializeReply.Unmarshal(m, b)
|
|
}
|
|
func (m *InitializeReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_InitializeReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *InitializeReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_InitializeReply.Merge(m, src)
|
|
}
|
|
func (m *InitializeReply) XXX_Size() int {
|
|
return xxx_messageInfo_InitializeReply.Size(m)
|
|
}
|
|
func (m *InitializeReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_InitializeReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_InitializeReply proto.InternalMessageInfo
|
|
|
|
func (m *InitializeReply) GetErr() *ProtoError {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SpecialPathsReply is the reply for SpecialPaths method.
|
|
type SpecialPathsReply struct {
|
|
Paths *Paths `sentinel:"" protobuf:"bytes,1,opt,name=paths,proto3" json:"paths,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SpecialPathsReply) Reset() { *m = SpecialPathsReply{} }
|
|
func (m *SpecialPathsReply) String() string { return proto.CompactTextString(m) }
|
|
func (*SpecialPathsReply) ProtoMessage() {}
|
|
func (*SpecialPathsReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{16}
|
|
}
|
|
|
|
func (m *SpecialPathsReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_SpecialPathsReply.Unmarshal(m, b)
|
|
}
|
|
func (m *SpecialPathsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_SpecialPathsReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *SpecialPathsReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SpecialPathsReply.Merge(m, src)
|
|
}
|
|
func (m *SpecialPathsReply) XXX_Size() int {
|
|
return xxx_messageInfo_SpecialPathsReply.Size(m)
|
|
}
|
|
func (m *SpecialPathsReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SpecialPathsReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SpecialPathsReply proto.InternalMessageInfo
|
|
|
|
func (m *SpecialPathsReply) GetPaths() *Paths {
|
|
if m != nil {
|
|
return m.Paths
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HandleExistenceCheckArgs is the args for HandleExistenceCheck method.
|
|
type HandleExistenceCheckArgs struct {
|
|
StorageID uint32 `sentinel:"" protobuf:"varint,1,opt,name=storage_id,json=storageId,proto3" json:"storage_id,omitempty"`
|
|
Request *Request `sentinel:"" protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *HandleExistenceCheckArgs) Reset() { *m = HandleExistenceCheckArgs{} }
|
|
func (m *HandleExistenceCheckArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*HandleExistenceCheckArgs) ProtoMessage() {}
|
|
func (*HandleExistenceCheckArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{17}
|
|
}
|
|
|
|
func (m *HandleExistenceCheckArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_HandleExistenceCheckArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *HandleExistenceCheckArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_HandleExistenceCheckArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *HandleExistenceCheckArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_HandleExistenceCheckArgs.Merge(m, src)
|
|
}
|
|
func (m *HandleExistenceCheckArgs) XXX_Size() int {
|
|
return xxx_messageInfo_HandleExistenceCheckArgs.Size(m)
|
|
}
|
|
func (m *HandleExistenceCheckArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_HandleExistenceCheckArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_HandleExistenceCheckArgs proto.InternalMessageInfo
|
|
|
|
func (m *HandleExistenceCheckArgs) GetStorageID() uint32 {
|
|
if m != nil {
|
|
return m.StorageID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *HandleExistenceCheckArgs) GetRequest() *Request {
|
|
if m != nil {
|
|
return m.Request
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HandleExistenceCheckReply is the reply for HandleExistenceCheck method.
|
|
type HandleExistenceCheckReply struct {
|
|
CheckFound bool `sentinel:"" protobuf:"varint,1,opt,name=check_found,json=checkFound,proto3" json:"check_found,omitempty"`
|
|
Exists bool `sentinel:"" protobuf:"varint,2,opt,name=exists,proto3" json:"exists,omitempty"`
|
|
Err *ProtoError `sentinel:"" protobuf:"bytes,3,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *HandleExistenceCheckReply) Reset() { *m = HandleExistenceCheckReply{} }
|
|
func (m *HandleExistenceCheckReply) String() string { return proto.CompactTextString(m) }
|
|
func (*HandleExistenceCheckReply) ProtoMessage() {}
|
|
func (*HandleExistenceCheckReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{18}
|
|
}
|
|
|
|
func (m *HandleExistenceCheckReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_HandleExistenceCheckReply.Unmarshal(m, b)
|
|
}
|
|
func (m *HandleExistenceCheckReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_HandleExistenceCheckReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *HandleExistenceCheckReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_HandleExistenceCheckReply.Merge(m, src)
|
|
}
|
|
func (m *HandleExistenceCheckReply) XXX_Size() int {
|
|
return xxx_messageInfo_HandleExistenceCheckReply.Size(m)
|
|
}
|
|
func (m *HandleExistenceCheckReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_HandleExistenceCheckReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_HandleExistenceCheckReply proto.InternalMessageInfo
|
|
|
|
func (m *HandleExistenceCheckReply) GetCheckFound() bool {
|
|
if m != nil {
|
|
return m.CheckFound
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *HandleExistenceCheckReply) GetExists() bool {
|
|
if m != nil {
|
|
return m.Exists
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *HandleExistenceCheckReply) GetErr() *ProtoError {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetupArgs is the args for Setup method.
|
|
type SetupArgs struct {
|
|
BrokerID uint32 `sentinel:"" protobuf:"varint,1,opt,name=broker_id,json=brokerId,proto3" json:"broker_id,omitempty"`
|
|
Config map[string]string `sentinel:"" protobuf:"bytes,2,rep,name=Config,proto3" json:"Config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
BackendUUID string `sentinel:"" protobuf:"bytes,3,opt,name=backendUUID,proto3" json:"backendUUID,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetupArgs) Reset() { *m = SetupArgs{} }
|
|
func (m *SetupArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*SetupArgs) ProtoMessage() {}
|
|
func (*SetupArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{19}
|
|
}
|
|
|
|
func (m *SetupArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_SetupArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *SetupArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_SetupArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *SetupArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetupArgs.Merge(m, src)
|
|
}
|
|
func (m *SetupArgs) XXX_Size() int {
|
|
return xxx_messageInfo_SetupArgs.Size(m)
|
|
}
|
|
func (m *SetupArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetupArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetupArgs proto.InternalMessageInfo
|
|
|
|
func (m *SetupArgs) GetBrokerID() uint32 {
|
|
if m != nil {
|
|
return m.BrokerID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *SetupArgs) GetConfig() map[string]string {
|
|
if m != nil {
|
|
return m.Config
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetupArgs) GetBackendUUID() string {
|
|
if m != nil {
|
|
return m.BackendUUID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// SetupReply is the reply for Setup method.
|
|
type SetupReply struct {
|
|
Err string `sentinel:"" protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetupReply) Reset() { *m = SetupReply{} }
|
|
func (m *SetupReply) String() string { return proto.CompactTextString(m) }
|
|
func (*SetupReply) ProtoMessage() {}
|
|
func (*SetupReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{20}
|
|
}
|
|
|
|
func (m *SetupReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_SetupReply.Unmarshal(m, b)
|
|
}
|
|
func (m *SetupReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_SetupReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *SetupReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetupReply.Merge(m, src)
|
|
}
|
|
func (m *SetupReply) XXX_Size() int {
|
|
return xxx_messageInfo_SetupReply.Size(m)
|
|
}
|
|
func (m *SetupReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetupReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetupReply proto.InternalMessageInfo
|
|
|
|
func (m *SetupReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// TypeReply is the reply for the Type method.
|
|
type TypeReply struct {
|
|
Type uint32 `sentinel:"" protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *TypeReply) Reset() { *m = TypeReply{} }
|
|
func (m *TypeReply) String() string { return proto.CompactTextString(m) }
|
|
func (*TypeReply) ProtoMessage() {}
|
|
func (*TypeReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{21}
|
|
}
|
|
|
|
func (m *TypeReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_TypeReply.Unmarshal(m, b)
|
|
}
|
|
func (m *TypeReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_TypeReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *TypeReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TypeReply.Merge(m, src)
|
|
}
|
|
func (m *TypeReply) XXX_Size() int {
|
|
return xxx_messageInfo_TypeReply.Size(m)
|
|
}
|
|
func (m *TypeReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TypeReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TypeReply proto.InternalMessageInfo
|
|
|
|
func (m *TypeReply) GetType() uint32 {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type InvalidateKeyArgs struct {
|
|
Key string `sentinel:"" protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *InvalidateKeyArgs) Reset() { *m = InvalidateKeyArgs{} }
|
|
func (m *InvalidateKeyArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*InvalidateKeyArgs) ProtoMessage() {}
|
|
func (*InvalidateKeyArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{22}
|
|
}
|
|
|
|
func (m *InvalidateKeyArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_InvalidateKeyArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *InvalidateKeyArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_InvalidateKeyArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *InvalidateKeyArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_InvalidateKeyArgs.Merge(m, src)
|
|
}
|
|
func (m *InvalidateKeyArgs) XXX_Size() int {
|
|
return xxx_messageInfo_InvalidateKeyArgs.Size(m)
|
|
}
|
|
func (m *InvalidateKeyArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_InvalidateKeyArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_InvalidateKeyArgs proto.InternalMessageInfo
|
|
|
|
func (m *InvalidateKeyArgs) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageEntry struct {
|
|
Key string `sentinel:"" protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
Value []byte `sentinel:"" protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
SealWrap bool `sentinel:"" protobuf:"varint,3,opt,name=seal_wrap,json=sealWrap,proto3" json:"seal_wrap,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageEntry) Reset() { *m = StorageEntry{} }
|
|
func (m *StorageEntry) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageEntry) ProtoMessage() {}
|
|
func (*StorageEntry) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{23}
|
|
}
|
|
|
|
func (m *StorageEntry) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageEntry.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageEntry.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageEntry) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageEntry.Merge(m, src)
|
|
}
|
|
func (m *StorageEntry) XXX_Size() int {
|
|
return xxx_messageInfo_StorageEntry.Size(m)
|
|
}
|
|
func (m *StorageEntry) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageEntry.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageEntry proto.InternalMessageInfo
|
|
|
|
func (m *StorageEntry) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *StorageEntry) GetValue() []byte {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *StorageEntry) GetSealWrap() bool {
|
|
if m != nil {
|
|
return m.SealWrap
|
|
}
|
|
return false
|
|
}
|
|
|
|
type StorageListArgs struct {
|
|
Prefix string `sentinel:"" protobuf:"bytes,1,opt,name=prefix,proto3" json:"prefix,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageListArgs) Reset() { *m = StorageListArgs{} }
|
|
func (m *StorageListArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageListArgs) ProtoMessage() {}
|
|
func (*StorageListArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{24}
|
|
}
|
|
|
|
func (m *StorageListArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageListArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageListArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageListArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageListArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageListArgs.Merge(m, src)
|
|
}
|
|
func (m *StorageListArgs) XXX_Size() int {
|
|
return xxx_messageInfo_StorageListArgs.Size(m)
|
|
}
|
|
func (m *StorageListArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageListArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageListArgs proto.InternalMessageInfo
|
|
|
|
func (m *StorageListArgs) GetPrefix() string {
|
|
if m != nil {
|
|
return m.Prefix
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageListReply struct {
|
|
Keys []string `sentinel:"" protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
|
|
Err string `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageListReply) Reset() { *m = StorageListReply{} }
|
|
func (m *StorageListReply) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageListReply) ProtoMessage() {}
|
|
func (*StorageListReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{25}
|
|
}
|
|
|
|
func (m *StorageListReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageListReply.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageListReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageListReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageListReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageListReply.Merge(m, src)
|
|
}
|
|
func (m *StorageListReply) XXX_Size() int {
|
|
return xxx_messageInfo_StorageListReply.Size(m)
|
|
}
|
|
func (m *StorageListReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageListReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageListReply proto.InternalMessageInfo
|
|
|
|
func (m *StorageListReply) GetKeys() []string {
|
|
if m != nil {
|
|
return m.Keys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *StorageListReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageGetArgs struct {
|
|
Key string `sentinel:"" protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageGetArgs) Reset() { *m = StorageGetArgs{} }
|
|
func (m *StorageGetArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageGetArgs) ProtoMessage() {}
|
|
func (*StorageGetArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{26}
|
|
}
|
|
|
|
func (m *StorageGetArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageGetArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageGetArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageGetArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageGetArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageGetArgs.Merge(m, src)
|
|
}
|
|
func (m *StorageGetArgs) XXX_Size() int {
|
|
return xxx_messageInfo_StorageGetArgs.Size(m)
|
|
}
|
|
func (m *StorageGetArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageGetArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageGetArgs proto.InternalMessageInfo
|
|
|
|
func (m *StorageGetArgs) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageGetReply struct {
|
|
Entry *StorageEntry `sentinel:"" protobuf:"bytes,1,opt,name=entry,proto3" json:"entry,omitempty"`
|
|
Err string `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageGetReply) Reset() { *m = StorageGetReply{} }
|
|
func (m *StorageGetReply) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageGetReply) ProtoMessage() {}
|
|
func (*StorageGetReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{27}
|
|
}
|
|
|
|
func (m *StorageGetReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageGetReply.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageGetReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageGetReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageGetReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageGetReply.Merge(m, src)
|
|
}
|
|
func (m *StorageGetReply) XXX_Size() int {
|
|
return xxx_messageInfo_StorageGetReply.Size(m)
|
|
}
|
|
func (m *StorageGetReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageGetReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageGetReply proto.InternalMessageInfo
|
|
|
|
func (m *StorageGetReply) GetEntry() *StorageEntry {
|
|
if m != nil {
|
|
return m.Entry
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *StorageGetReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StoragePutArgs struct {
|
|
Entry *StorageEntry `sentinel:"" protobuf:"bytes,1,opt,name=entry,proto3" json:"entry,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StoragePutArgs) Reset() { *m = StoragePutArgs{} }
|
|
func (m *StoragePutArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*StoragePutArgs) ProtoMessage() {}
|
|
func (*StoragePutArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{28}
|
|
}
|
|
|
|
func (m *StoragePutArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StoragePutArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *StoragePutArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StoragePutArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StoragePutArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StoragePutArgs.Merge(m, src)
|
|
}
|
|
func (m *StoragePutArgs) XXX_Size() int {
|
|
return xxx_messageInfo_StoragePutArgs.Size(m)
|
|
}
|
|
func (m *StoragePutArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StoragePutArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StoragePutArgs proto.InternalMessageInfo
|
|
|
|
func (m *StoragePutArgs) GetEntry() *StorageEntry {
|
|
if m != nil {
|
|
return m.Entry
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type StoragePutReply struct {
|
|
Err string `sentinel:"" protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StoragePutReply) Reset() { *m = StoragePutReply{} }
|
|
func (m *StoragePutReply) String() string { return proto.CompactTextString(m) }
|
|
func (*StoragePutReply) ProtoMessage() {}
|
|
func (*StoragePutReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{29}
|
|
}
|
|
|
|
func (m *StoragePutReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StoragePutReply.Unmarshal(m, b)
|
|
}
|
|
func (m *StoragePutReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StoragePutReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StoragePutReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StoragePutReply.Merge(m, src)
|
|
}
|
|
func (m *StoragePutReply) XXX_Size() int {
|
|
return xxx_messageInfo_StoragePutReply.Size(m)
|
|
}
|
|
func (m *StoragePutReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StoragePutReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StoragePutReply proto.InternalMessageInfo
|
|
|
|
func (m *StoragePutReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageDeleteArgs struct {
|
|
Key string `sentinel:"" protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageDeleteArgs) Reset() { *m = StorageDeleteArgs{} }
|
|
func (m *StorageDeleteArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageDeleteArgs) ProtoMessage() {}
|
|
func (*StorageDeleteArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{30}
|
|
}
|
|
|
|
func (m *StorageDeleteArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageDeleteArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageDeleteArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageDeleteArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageDeleteArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageDeleteArgs.Merge(m, src)
|
|
}
|
|
func (m *StorageDeleteArgs) XXX_Size() int {
|
|
return xxx_messageInfo_StorageDeleteArgs.Size(m)
|
|
}
|
|
func (m *StorageDeleteArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageDeleteArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageDeleteArgs proto.InternalMessageInfo
|
|
|
|
func (m *StorageDeleteArgs) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type StorageDeleteReply struct {
|
|
Err string `sentinel:"" protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *StorageDeleteReply) Reset() { *m = StorageDeleteReply{} }
|
|
func (m *StorageDeleteReply) String() string { return proto.CompactTextString(m) }
|
|
func (*StorageDeleteReply) ProtoMessage() {}
|
|
func (*StorageDeleteReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{31}
|
|
}
|
|
|
|
func (m *StorageDeleteReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_StorageDeleteReply.Unmarshal(m, b)
|
|
}
|
|
func (m *StorageDeleteReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_StorageDeleteReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *StorageDeleteReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_StorageDeleteReply.Merge(m, src)
|
|
}
|
|
func (m *StorageDeleteReply) XXX_Size() int {
|
|
return xxx_messageInfo_StorageDeleteReply.Size(m)
|
|
}
|
|
func (m *StorageDeleteReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_StorageDeleteReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_StorageDeleteReply proto.InternalMessageInfo
|
|
|
|
func (m *StorageDeleteReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type TTLReply struct {
|
|
TTL int64 `sentinel:"" protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *TTLReply) Reset() { *m = TTLReply{} }
|
|
func (m *TTLReply) String() string { return proto.CompactTextString(m) }
|
|
func (*TTLReply) ProtoMessage() {}
|
|
func (*TTLReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{32}
|
|
}
|
|
|
|
func (m *TTLReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_TTLReply.Unmarshal(m, b)
|
|
}
|
|
func (m *TTLReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_TTLReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *TTLReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TTLReply.Merge(m, src)
|
|
}
|
|
func (m *TTLReply) XXX_Size() int {
|
|
return xxx_messageInfo_TTLReply.Size(m)
|
|
}
|
|
func (m *TTLReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TTLReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TTLReply proto.InternalMessageInfo
|
|
|
|
func (m *TTLReply) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type TaintedReply struct {
|
|
Tainted bool `sentinel:"" protobuf:"varint,1,opt,name=tainted,proto3" json:"tainted,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *TaintedReply) Reset() { *m = TaintedReply{} }
|
|
func (m *TaintedReply) String() string { return proto.CompactTextString(m) }
|
|
func (*TaintedReply) ProtoMessage() {}
|
|
func (*TaintedReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{33}
|
|
}
|
|
|
|
func (m *TaintedReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_TaintedReply.Unmarshal(m, b)
|
|
}
|
|
func (m *TaintedReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_TaintedReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *TaintedReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TaintedReply.Merge(m, src)
|
|
}
|
|
func (m *TaintedReply) XXX_Size() int {
|
|
return xxx_messageInfo_TaintedReply.Size(m)
|
|
}
|
|
func (m *TaintedReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TaintedReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TaintedReply proto.InternalMessageInfo
|
|
|
|
func (m *TaintedReply) GetTainted() bool {
|
|
if m != nil {
|
|
return m.Tainted
|
|
}
|
|
return false
|
|
}
|
|
|
|
type CachingDisabledReply struct {
|
|
Disabled bool `sentinel:"" protobuf:"varint,1,opt,name=disabled,proto3" json:"disabled,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *CachingDisabledReply) Reset() { *m = CachingDisabledReply{} }
|
|
func (m *CachingDisabledReply) String() string { return proto.CompactTextString(m) }
|
|
func (*CachingDisabledReply) ProtoMessage() {}
|
|
func (*CachingDisabledReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{34}
|
|
}
|
|
|
|
func (m *CachingDisabledReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_CachingDisabledReply.Unmarshal(m, b)
|
|
}
|
|
func (m *CachingDisabledReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_CachingDisabledReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *CachingDisabledReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_CachingDisabledReply.Merge(m, src)
|
|
}
|
|
func (m *CachingDisabledReply) XXX_Size() int {
|
|
return xxx_messageInfo_CachingDisabledReply.Size(m)
|
|
}
|
|
func (m *CachingDisabledReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_CachingDisabledReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_CachingDisabledReply proto.InternalMessageInfo
|
|
|
|
func (m *CachingDisabledReply) GetDisabled() bool {
|
|
if m != nil {
|
|
return m.Disabled
|
|
}
|
|
return false
|
|
}
|
|
|
|
type ReplicationStateReply struct {
|
|
State int32 `sentinel:"" protobuf:"varint,1,opt,name=state,proto3" json:"state,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ReplicationStateReply) Reset() { *m = ReplicationStateReply{} }
|
|
func (m *ReplicationStateReply) String() string { return proto.CompactTextString(m) }
|
|
func (*ReplicationStateReply) ProtoMessage() {}
|
|
func (*ReplicationStateReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{35}
|
|
}
|
|
|
|
func (m *ReplicationStateReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ReplicationStateReply.Unmarshal(m, b)
|
|
}
|
|
func (m *ReplicationStateReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ReplicationStateReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ReplicationStateReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ReplicationStateReply.Merge(m, src)
|
|
}
|
|
func (m *ReplicationStateReply) XXX_Size() int {
|
|
return xxx_messageInfo_ReplicationStateReply.Size(m)
|
|
}
|
|
func (m *ReplicationStateReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ReplicationStateReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ReplicationStateReply proto.InternalMessageInfo
|
|
|
|
func (m *ReplicationStateReply) GetState() int32 {
|
|
if m != nil {
|
|
return m.State
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type ResponseWrapDataArgs struct {
|
|
Data string `sentinel:"" protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
|
|
TTL int64 `sentinel:"" protobuf:"varint,2,opt,name=TTL,proto3" json:"TTL,omitempty"`
|
|
JWT bool `sentinel:"" protobuf:"varint,3,opt,name=JWT,proto3" json:"JWT,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ResponseWrapDataArgs) Reset() { *m = ResponseWrapDataArgs{} }
|
|
func (m *ResponseWrapDataArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*ResponseWrapDataArgs) ProtoMessage() {}
|
|
func (*ResponseWrapDataArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{36}
|
|
}
|
|
|
|
func (m *ResponseWrapDataArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ResponseWrapDataArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *ResponseWrapDataArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ResponseWrapDataArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ResponseWrapDataArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ResponseWrapDataArgs.Merge(m, src)
|
|
}
|
|
func (m *ResponseWrapDataArgs) XXX_Size() int {
|
|
return xxx_messageInfo_ResponseWrapDataArgs.Size(m)
|
|
}
|
|
func (m *ResponseWrapDataArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ResponseWrapDataArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ResponseWrapDataArgs proto.InternalMessageInfo
|
|
|
|
func (m *ResponseWrapDataArgs) GetData() string {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ResponseWrapDataArgs) GetTTL() int64 {
|
|
if m != nil {
|
|
return m.TTL
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ResponseWrapDataArgs) GetJWT() bool {
|
|
if m != nil {
|
|
return m.JWT
|
|
}
|
|
return false
|
|
}
|
|
|
|
type ResponseWrapDataReply struct {
|
|
WrapInfo *ResponseWrapInfo `sentinel:"" protobuf:"bytes,1,opt,name=wrap_info,json=wrapInfo,proto3" json:"wrap_info,omitempty"`
|
|
Err string `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ResponseWrapDataReply) Reset() { *m = ResponseWrapDataReply{} }
|
|
func (m *ResponseWrapDataReply) String() string { return proto.CompactTextString(m) }
|
|
func (*ResponseWrapDataReply) ProtoMessage() {}
|
|
func (*ResponseWrapDataReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{37}
|
|
}
|
|
|
|
func (m *ResponseWrapDataReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_ResponseWrapDataReply.Unmarshal(m, b)
|
|
}
|
|
func (m *ResponseWrapDataReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_ResponseWrapDataReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *ResponseWrapDataReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ResponseWrapDataReply.Merge(m, src)
|
|
}
|
|
func (m *ResponseWrapDataReply) XXX_Size() int {
|
|
return xxx_messageInfo_ResponseWrapDataReply.Size(m)
|
|
}
|
|
func (m *ResponseWrapDataReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ResponseWrapDataReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ResponseWrapDataReply proto.InternalMessageInfo
|
|
|
|
func (m *ResponseWrapDataReply) GetWrapInfo() *ResponseWrapInfo {
|
|
if m != nil {
|
|
return m.WrapInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResponseWrapDataReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type MlockEnabledReply struct {
|
|
Enabled bool `sentinel:"" protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *MlockEnabledReply) Reset() { *m = MlockEnabledReply{} }
|
|
func (m *MlockEnabledReply) String() string { return proto.CompactTextString(m) }
|
|
func (*MlockEnabledReply) ProtoMessage() {}
|
|
func (*MlockEnabledReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{38}
|
|
}
|
|
|
|
func (m *MlockEnabledReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_MlockEnabledReply.Unmarshal(m, b)
|
|
}
|
|
func (m *MlockEnabledReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_MlockEnabledReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *MlockEnabledReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_MlockEnabledReply.Merge(m, src)
|
|
}
|
|
func (m *MlockEnabledReply) XXX_Size() int {
|
|
return xxx_messageInfo_MlockEnabledReply.Size(m)
|
|
}
|
|
func (m *MlockEnabledReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_MlockEnabledReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_MlockEnabledReply proto.InternalMessageInfo
|
|
|
|
func (m *MlockEnabledReply) GetEnabled() bool {
|
|
if m != nil {
|
|
return m.Enabled
|
|
}
|
|
return false
|
|
}
|
|
|
|
type LocalMountReply struct {
|
|
Local bool `sentinel:"" protobuf:"varint,1,opt,name=local,proto3" json:"local,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *LocalMountReply) Reset() { *m = LocalMountReply{} }
|
|
func (m *LocalMountReply) String() string { return proto.CompactTextString(m) }
|
|
func (*LocalMountReply) ProtoMessage() {}
|
|
func (*LocalMountReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{39}
|
|
}
|
|
|
|
func (m *LocalMountReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_LocalMountReply.Unmarshal(m, b)
|
|
}
|
|
func (m *LocalMountReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_LocalMountReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *LocalMountReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_LocalMountReply.Merge(m, src)
|
|
}
|
|
func (m *LocalMountReply) XXX_Size() int {
|
|
return xxx_messageInfo_LocalMountReply.Size(m)
|
|
}
|
|
func (m *LocalMountReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_LocalMountReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_LocalMountReply proto.InternalMessageInfo
|
|
|
|
func (m *LocalMountReply) GetLocal() bool {
|
|
if m != nil {
|
|
return m.Local
|
|
}
|
|
return false
|
|
}
|
|
|
|
type EntityInfoArgs struct {
|
|
EntityID string `sentinel:"" protobuf:"bytes,1,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *EntityInfoArgs) Reset() { *m = EntityInfoArgs{} }
|
|
func (m *EntityInfoArgs) String() string { return proto.CompactTextString(m) }
|
|
func (*EntityInfoArgs) ProtoMessage() {}
|
|
func (*EntityInfoArgs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{40}
|
|
}
|
|
|
|
func (m *EntityInfoArgs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_EntityInfoArgs.Unmarshal(m, b)
|
|
}
|
|
func (m *EntityInfoArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_EntityInfoArgs.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *EntityInfoArgs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_EntityInfoArgs.Merge(m, src)
|
|
}
|
|
func (m *EntityInfoArgs) XXX_Size() int {
|
|
return xxx_messageInfo_EntityInfoArgs.Size(m)
|
|
}
|
|
func (m *EntityInfoArgs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_EntityInfoArgs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_EntityInfoArgs proto.InternalMessageInfo
|
|
|
|
func (m *EntityInfoArgs) GetEntityID() string {
|
|
if m != nil {
|
|
return m.EntityID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type EntityInfoReply struct {
|
|
Entity *logical.Entity `sentinel:"" protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"`
|
|
Err string `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *EntityInfoReply) Reset() { *m = EntityInfoReply{} }
|
|
func (m *EntityInfoReply) String() string { return proto.CompactTextString(m) }
|
|
func (*EntityInfoReply) ProtoMessage() {}
|
|
func (*EntityInfoReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{41}
|
|
}
|
|
|
|
func (m *EntityInfoReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_EntityInfoReply.Unmarshal(m, b)
|
|
}
|
|
func (m *EntityInfoReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_EntityInfoReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *EntityInfoReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_EntityInfoReply.Merge(m, src)
|
|
}
|
|
func (m *EntityInfoReply) XXX_Size() int {
|
|
return xxx_messageInfo_EntityInfoReply.Size(m)
|
|
}
|
|
func (m *EntityInfoReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_EntityInfoReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_EntityInfoReply proto.InternalMessageInfo
|
|
|
|
func (m *EntityInfoReply) GetEntity() *logical.Entity {
|
|
if m != nil {
|
|
return m.Entity
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *EntityInfoReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type PluginEnvReply struct {
|
|
PluginEnvironment *logical.PluginEnvironment `sentinel:"" protobuf:"bytes,1,opt,name=plugin_environment,json=pluginEnvironment,proto3" json:"plugin_environment,omitempty"`
|
|
Err string `sentinel:"" protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PluginEnvReply) Reset() { *m = PluginEnvReply{} }
|
|
func (m *PluginEnvReply) String() string { return proto.CompactTextString(m) }
|
|
func (*PluginEnvReply) ProtoMessage() {}
|
|
func (*PluginEnvReply) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{42}
|
|
}
|
|
|
|
func (m *PluginEnvReply) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_PluginEnvReply.Unmarshal(m, b)
|
|
}
|
|
func (m *PluginEnvReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_PluginEnvReply.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *PluginEnvReply) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PluginEnvReply.Merge(m, src)
|
|
}
|
|
func (m *PluginEnvReply) XXX_Size() int {
|
|
return xxx_messageInfo_PluginEnvReply.Size(m)
|
|
}
|
|
func (m *PluginEnvReply) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PluginEnvReply.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PluginEnvReply proto.InternalMessageInfo
|
|
|
|
func (m *PluginEnvReply) GetPluginEnvironment() *logical.PluginEnvironment {
|
|
if m != nil {
|
|
return m.PluginEnvironment
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PluginEnvReply) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Connection struct {
|
|
// RemoteAddr is the network address that sent the request.
|
|
RemoteAddr string `sentinel:"" protobuf:"bytes,1,opt,name=remote_addr,json=remoteAddr,proto3" json:"remote_addr,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Connection) Reset() { *m = Connection{} }
|
|
func (m *Connection) String() string { return proto.CompactTextString(m) }
|
|
func (*Connection) ProtoMessage() {}
|
|
func (*Connection) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_4dbf1dfe0c11846b, []int{43}
|
|
}
|
|
|
|
func (m *Connection) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Connection.Unmarshal(m, b)
|
|
}
|
|
func (m *Connection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Connection.Marshal(b, m, deterministic)
|
|
}
|
|
func (m *Connection) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Connection.Merge(m, src)
|
|
}
|
|
func (m *Connection) XXX_Size() int {
|
|
return xxx_messageInfo_Connection.Size(m)
|
|
}
|
|
func (m *Connection) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Connection.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Connection proto.InternalMessageInfo
|
|
|
|
func (m *Connection) GetRemoteAddr() string {
|
|
if m != nil {
|
|
return m.RemoteAddr
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*Empty)(nil), "pb.Empty")
|
|
proto.RegisterType((*Header)(nil), "pb.Header")
|
|
proto.RegisterType((*ProtoError)(nil), "pb.ProtoError")
|
|
proto.RegisterType((*Paths)(nil), "pb.Paths")
|
|
proto.RegisterType((*Request)(nil), "pb.Request")
|
|
proto.RegisterMapType((map[string]*Header)(nil), "pb.Request.HeadersEntry")
|
|
proto.RegisterType((*Auth)(nil), "pb.Auth")
|
|
proto.RegisterMapType((map[string]string)(nil), "pb.Auth.MetadataEntry")
|
|
proto.RegisterType((*TokenEntry)(nil), "pb.TokenEntry")
|
|
proto.RegisterMapType((map[string]string)(nil), "pb.TokenEntry.MetaEntry")
|
|
proto.RegisterType((*LeaseOptions)(nil), "pb.LeaseOptions")
|
|
proto.RegisterType((*Secret)(nil), "pb.Secret")
|
|
proto.RegisterType((*Response)(nil), "pb.Response")
|
|
proto.RegisterMapType((map[string]*Header)(nil), "pb.Response.HeadersEntry")
|
|
proto.RegisterType((*ResponseWrapInfo)(nil), "pb.ResponseWrapInfo")
|
|
proto.RegisterType((*RequestWrapInfo)(nil), "pb.RequestWrapInfo")
|
|
proto.RegisterType((*HandleRequestArgs)(nil), "pb.HandleRequestArgs")
|
|
proto.RegisterType((*HandleRequestReply)(nil), "pb.HandleRequestReply")
|
|
proto.RegisterType((*InitializeArgs)(nil), "pb.InitializeArgs")
|
|
proto.RegisterType((*InitializeReply)(nil), "pb.InitializeReply")
|
|
proto.RegisterType((*SpecialPathsReply)(nil), "pb.SpecialPathsReply")
|
|
proto.RegisterType((*HandleExistenceCheckArgs)(nil), "pb.HandleExistenceCheckArgs")
|
|
proto.RegisterType((*HandleExistenceCheckReply)(nil), "pb.HandleExistenceCheckReply")
|
|
proto.RegisterType((*SetupArgs)(nil), "pb.SetupArgs")
|
|
proto.RegisterMapType((map[string]string)(nil), "pb.SetupArgs.ConfigEntry")
|
|
proto.RegisterType((*SetupReply)(nil), "pb.SetupReply")
|
|
proto.RegisterType((*TypeReply)(nil), "pb.TypeReply")
|
|
proto.RegisterType((*InvalidateKeyArgs)(nil), "pb.InvalidateKeyArgs")
|
|
proto.RegisterType((*StorageEntry)(nil), "pb.StorageEntry")
|
|
proto.RegisterType((*StorageListArgs)(nil), "pb.StorageListArgs")
|
|
proto.RegisterType((*StorageListReply)(nil), "pb.StorageListReply")
|
|
proto.RegisterType((*StorageGetArgs)(nil), "pb.StorageGetArgs")
|
|
proto.RegisterType((*StorageGetReply)(nil), "pb.StorageGetReply")
|
|
proto.RegisterType((*StoragePutArgs)(nil), "pb.StoragePutArgs")
|
|
proto.RegisterType((*StoragePutReply)(nil), "pb.StoragePutReply")
|
|
proto.RegisterType((*StorageDeleteArgs)(nil), "pb.StorageDeleteArgs")
|
|
proto.RegisterType((*StorageDeleteReply)(nil), "pb.StorageDeleteReply")
|
|
proto.RegisterType((*TTLReply)(nil), "pb.TTLReply")
|
|
proto.RegisterType((*TaintedReply)(nil), "pb.TaintedReply")
|
|
proto.RegisterType((*CachingDisabledReply)(nil), "pb.CachingDisabledReply")
|
|
proto.RegisterType((*ReplicationStateReply)(nil), "pb.ReplicationStateReply")
|
|
proto.RegisterType((*ResponseWrapDataArgs)(nil), "pb.ResponseWrapDataArgs")
|
|
proto.RegisterType((*ResponseWrapDataReply)(nil), "pb.ResponseWrapDataReply")
|
|
proto.RegisterType((*MlockEnabledReply)(nil), "pb.MlockEnabledReply")
|
|
proto.RegisterType((*LocalMountReply)(nil), "pb.LocalMountReply")
|
|
proto.RegisterType((*EntityInfoArgs)(nil), "pb.EntityInfoArgs")
|
|
proto.RegisterType((*EntityInfoReply)(nil), "pb.EntityInfoReply")
|
|
proto.RegisterType((*PluginEnvReply)(nil), "pb.PluginEnvReply")
|
|
proto.RegisterType((*Connection)(nil), "pb.Connection")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("sdk/plugin/pb/backend.proto", fileDescriptor_4dbf1dfe0c11846b) }
|
|
|
|
var fileDescriptor_4dbf1dfe0c11846b = []byte{
|
|
// 2504 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcd, 0x72, 0x1b, 0xc7,
|
|
0x11, 0x2e, 0x00, 0xc4, 0x5f, 0xe3, 0x7f, 0x48, 0x2b, 0x2b, 0x48, 0x8e, 0xe8, 0x75, 0x24, 0xd3,
|
|
0x8c, 0x0d, 0x5a, 0x54, 0x14, 0xcb, 0x49, 0x25, 0x29, 0x9a, 0xa2, 0x65, 0xc6, 0xa4, 0xcd, 0x5a,
|
|
0x42, 0x71, 0xfe, 0xaa, 0xe0, 0xc1, 0xee, 0x10, 0xdc, 0xe2, 0x62, 0x77, 0x33, 0x3b, 0x4b, 0x11,
|
|
0xb9, 0xe4, 0x96, 0x47, 0xc8, 0x1b, 0xe4, 0x9c, 0x6b, 0x6e, 0xb9, 0xba, 0x72, 0xcf, 0x2b, 0xe4,
|
|
0x39, 0x52, 0xd3, 0x33, 0xfb, 0x07, 0x80, 0xb6, 0x5c, 0xe5, 0xdc, 0x76, 0xba, 0x7b, 0x7a, 0x66,
|
|
0x7a, 0xbe, 0xfe, 0xba, 0x07, 0x80, 0x7b, 0x91, 0x73, 0xb5, 0x17, 0x7a, 0xf1, 0xcc, 0xf5, 0xf7,
|
|
0xc2, 0xe9, 0xde, 0x94, 0xda, 0x57, 0xcc, 0x77, 0x46, 0x21, 0x0f, 0x44, 0x40, 0xca, 0xe1, 0x74,
|
|
0xf8, 0x60, 0x16, 0x04, 0x33, 0x8f, 0xed, 0xa1, 0x64, 0x1a, 0x5f, 0xec, 0x09, 0x77, 0xce, 0x22,
|
|
0x41, 0xe7, 0xa1, 0x32, 0x1a, 0x0e, 0xa5, 0x07, 0x2f, 0x98, 0xb9, 0x36, 0xf5, 0xf6, 0x5c, 0x87,
|
|
0xf9, 0xc2, 0x15, 0x0b, 0xad, 0x33, 0xf2, 0x3a, 0xb5, 0x8a, 0xd2, 0x98, 0x75, 0xa8, 0x1e, 0xcd,
|
|
0x43, 0xb1, 0x30, 0xb7, 0xa1, 0xf6, 0x29, 0xa3, 0x0e, 0xe3, 0xe4, 0x0e, 0xd4, 0x2e, 0xf1, 0xcb,
|
|
0x28, 0x6d, 0x57, 0x76, 0x9a, 0x96, 0x1e, 0x99, 0x7f, 0x00, 0x38, 0x93, 0x73, 0x8e, 0x38, 0x0f,
|
|
0x38, 0xb9, 0x0b, 0x0d, 0xc6, 0xf9, 0x44, 0x2c, 0x42, 0x66, 0x94, 0xb6, 0x4b, 0x3b, 0x1d, 0xab,
|
|
0xce, 0x38, 0x1f, 0x2f, 0x42, 0x46, 0x7e, 0x00, 0xf2, 0x73, 0x32, 0x8f, 0x66, 0x46, 0x79, 0xbb,
|
|
0x24, 0x3d, 0x30, 0xce, 0x4f, 0xa3, 0x59, 0x32, 0xc7, 0x0e, 0x1c, 0x66, 0x54, 0xb6, 0x4b, 0x3b,
|
|
0x15, 0x9c, 0x73, 0x18, 0x38, 0xcc, 0xfc, 0x5b, 0x09, 0xaa, 0x67, 0x54, 0x5c, 0x46, 0x84, 0xc0,
|
|
0x06, 0x0f, 0x02, 0xa1, 0x17, 0xc7, 0x6f, 0xb2, 0x03, 0xbd, 0xd8, 0xa7, 0xb1, 0xb8, 0x94, 0xa7,
|
|
0xb2, 0xa9, 0x60, 0x8e, 0x51, 0x46, 0xf5, 0xb2, 0x98, 0xbc, 0x0d, 0x1d, 0x2f, 0xb0, 0xa9, 0x37,
|
|
0x89, 0x44, 0xc0, 0xe9, 0x4c, 0xae, 0x23, 0xed, 0xda, 0x28, 0x3c, 0x57, 0x32, 0xb2, 0x0b, 0x83,
|
|
0x88, 0x51, 0x6f, 0xf2, 0x8a, 0xd3, 0x30, 0x35, 0xdc, 0x50, 0x0e, 0xa5, 0xe2, 0x4b, 0x4e, 0x43,
|
|
0x6d, 0x6b, 0xfe, 0xab, 0x06, 0x75, 0x8b, 0xfd, 0x29, 0x66, 0x91, 0x20, 0x5d, 0x28, 0xbb, 0x0e,
|
|
0x9e, 0xb6, 0x69, 0x95, 0x5d, 0x87, 0x8c, 0x80, 0x58, 0x2c, 0xf4, 0xe4, 0xd2, 0x6e, 0xe0, 0x1f,
|
|
0x7a, 0x71, 0x24, 0x18, 0xd7, 0x67, 0x5e, 0xa3, 0x21, 0xf7, 0xa1, 0x19, 0x84, 0x8c, 0xa3, 0x0c,
|
|
0x03, 0xd0, 0xb4, 0x32, 0x81, 0x3c, 0x78, 0x48, 0xc5, 0xa5, 0xb1, 0x81, 0x0a, 0xfc, 0x96, 0x32,
|
|
0x87, 0x0a, 0x6a, 0x54, 0x95, 0x4c, 0x7e, 0x13, 0x13, 0x6a, 0x11, 0xb3, 0x39, 0x13, 0x46, 0x6d,
|
|
0xbb, 0xb4, 0xd3, 0xda, 0x87, 0x51, 0x38, 0x1d, 0x9d, 0xa3, 0xc4, 0xd2, 0x1a, 0x72, 0x1f, 0x36,
|
|
0x64, 0x5c, 0x8c, 0x3a, 0x5a, 0x34, 0xa4, 0xc5, 0x41, 0x2c, 0x2e, 0x2d, 0x94, 0x92, 0x7d, 0xa8,
|
|
0xab, 0x3b, 0x8d, 0x8c, 0xc6, 0x76, 0x65, 0xa7, 0xb5, 0x6f, 0x48, 0x03, 0x7d, 0xca, 0x91, 0x82,
|
|
0x41, 0x74, 0xe4, 0x0b, 0xbe, 0xb0, 0x12, 0x43, 0xf2, 0x16, 0xb4, 0x6d, 0xcf, 0x65, 0xbe, 0x98,
|
|
0x88, 0xe0, 0x8a, 0xf9, 0x46, 0x13, 0x77, 0xd4, 0x52, 0xb2, 0xb1, 0x14, 0x91, 0x7d, 0x78, 0x23,
|
|
0x6f, 0x32, 0xa1, 0xb6, 0xcd, 0xa2, 0x28, 0xe0, 0x06, 0xa0, 0xed, 0x66, 0xce, 0xf6, 0x40, 0xab,
|
|
0xa4, 0x5b, 0xc7, 0x8d, 0x42, 0x8f, 0x2e, 0x26, 0x3e, 0x9d, 0x33, 0xa3, 0xa5, 0xdc, 0x6a, 0xd9,
|
|
0xe7, 0x74, 0xce, 0xc8, 0x03, 0x68, 0xcd, 0x83, 0xd8, 0x17, 0x93, 0x30, 0x70, 0x7d, 0x61, 0xb4,
|
|
0xd1, 0x02, 0x50, 0x74, 0x26, 0x25, 0xe4, 0x4d, 0x50, 0x23, 0x05, 0xc6, 0x8e, 0x8a, 0x2b, 0x4a,
|
|
0x10, 0x8e, 0x0f, 0xa1, 0xab, 0xd4, 0xe9, 0x7e, 0xba, 0x68, 0xd2, 0x41, 0x69, 0xba, 0x93, 0x0f,
|
|
0xa0, 0x89, 0x78, 0x70, 0xfd, 0x8b, 0xc0, 0xe8, 0x61, 0xdc, 0x36, 0x73, 0x61, 0x91, 0x98, 0x38,
|
|
0xf6, 0x2f, 0x02, 0xab, 0xf1, 0x4a, 0x7f, 0x91, 0x5f, 0xc0, 0xbd, 0xc2, 0x79, 0x39, 0x9b, 0x53,
|
|
0xd7, 0x77, 0xfd, 0xd9, 0x24, 0x8e, 0x58, 0x64, 0xf4, 0x11, 0xe1, 0x46, 0xee, 0xd4, 0x56, 0x62,
|
|
0xf0, 0x32, 0x62, 0x11, 0xb9, 0x07, 0x4d, 0x95, 0xa4, 0x13, 0xd7, 0x31, 0x06, 0xb8, 0xa5, 0x86,
|
|
0x12, 0x1c, 0x3b, 0xe4, 0x1d, 0xe8, 0x85, 0x81, 0xe7, 0xda, 0x8b, 0x49, 0x70, 0xcd, 0x38, 0x77,
|
|
0x1d, 0x66, 0x90, 0xed, 0xd2, 0x4e, 0xc3, 0xea, 0x2a, 0xf1, 0x17, 0x5a, 0xba, 0x2e, 0x35, 0x36,
|
|
0xd1, 0x70, 0x25, 0x35, 0x46, 0x00, 0x76, 0xe0, 0xfb, 0xcc, 0x46, 0xf8, 0x6d, 0xe1, 0x09, 0xbb,
|
|
0xf2, 0x84, 0x87, 0xa9, 0xd4, 0xca, 0x59, 0x0c, 0x3f, 0x81, 0x76, 0x1e, 0x0a, 0xa4, 0x0f, 0x95,
|
|
0x2b, 0xb6, 0xd0, 0xf0, 0x97, 0x9f, 0x64, 0x1b, 0xaa, 0xd7, 0xd4, 0x8b, 0x19, 0x42, 0x5e, 0x03,
|
|
0x51, 0x4d, 0xb1, 0x94, 0xe2, 0x67, 0xe5, 0x67, 0x25, 0xf3, 0xbf, 0x55, 0xd8, 0x90, 0xe0, 0x23,
|
|
0x4f, 0xa1, 0xe3, 0x31, 0x1a, 0xb1, 0x49, 0x10, 0xca, 0x05, 0x22, 0x74, 0xd5, 0xda, 0xef, 0xcb,
|
|
0x69, 0x27, 0x52, 0xf1, 0x85, 0x92, 0x5b, 0x6d, 0x2f, 0x37, 0x92, 0x29, 0xed, 0xfa, 0x82, 0x71,
|
|
0x9f, 0x7a, 0x13, 0x4c, 0x06, 0x95, 0x60, 0xed, 0x44, 0xf8, 0x5c, 0x26, 0xc5, 0x32, 0x8e, 0x2a,
|
|
0xab, 0x38, 0x1a, 0x42, 0x03, 0x63, 0xe7, 0xb2, 0x48, 0x27, 0x7b, 0x3a, 0x26, 0xfb, 0xd0, 0x98,
|
|
0x33, 0x41, 0x75, 0xae, 0xc9, 0x94, 0xb8, 0x93, 0xe4, 0xcc, 0xe8, 0x54, 0x2b, 0x54, 0x42, 0xa4,
|
|
0x76, 0x2b, 0x19, 0x51, 0x5b, 0xcd, 0x88, 0x21, 0x34, 0x52, 0xd0, 0xd5, 0xd5, 0x0d, 0x27, 0x63,
|
|
0x49, 0xb3, 0x21, 0xe3, 0x6e, 0xe0, 0x18, 0x0d, 0x04, 0x8a, 0x1e, 0x49, 0x92, 0xf4, 0xe3, 0xb9,
|
|
0x82, 0x50, 0x53, 0x91, 0xa4, 0x1f, 0xcf, 0x57, 0x11, 0x03, 0x4b, 0x88, 0xf9, 0x11, 0x54, 0xa9,
|
|
0xe7, 0xd2, 0x08, 0x53, 0x48, 0xde, 0xac, 0xe6, 0xfb, 0xd1, 0x81, 0x94, 0x5a, 0x4a, 0x49, 0x9e,
|
|
0x40, 0x67, 0xc6, 0x83, 0x38, 0x9c, 0xe0, 0x90, 0x45, 0x46, 0x1b, 0x4f, 0xbb, 0x6c, 0xdd, 0x46,
|
|
0xa3, 0x03, 0x65, 0x23, 0x33, 0x70, 0x1a, 0xc4, 0xbe, 0x33, 0xb1, 0x5d, 0x87, 0x47, 0x46, 0x07,
|
|
0x83, 0x07, 0x28, 0x3a, 0x94, 0x12, 0x99, 0x62, 0x2a, 0x05, 0xd2, 0x00, 0x77, 0xd1, 0xa6, 0x83,
|
|
0xd2, 0xb3, 0x24, 0xca, 0x3f, 0x86, 0x41, 0x52, 0x98, 0x32, 0xcb, 0x1e, 0x5a, 0xf6, 0x13, 0x45,
|
|
0x6a, 0xbc, 0x03, 0x7d, 0x76, 0x23, 0x29, 0xd4, 0x15, 0x93, 0x39, 0xbd, 0x99, 0x08, 0xe1, 0xe9,
|
|
0x94, 0xea, 0x26, 0xf2, 0x53, 0x7a, 0x33, 0x16, 0x9e, 0xcc, 0x7f, 0xb5, 0x3a, 0xe6, 0xff, 0x00,
|
|
0x8b, 0x51, 0x13, 0x25, 0x98, 0xff, 0xbb, 0x30, 0xf0, 0x83, 0x89, 0xc3, 0x2e, 0x68, 0xec, 0x09,
|
|
0xb5, 0xee, 0x42, 0x27, 0x53, 0xcf, 0x0f, 0x9e, 0x2b, 0x39, 0x2e, 0xbb, 0x18, 0xfe, 0x1c, 0x3a,
|
|
0x85, 0xeb, 0x5e, 0x03, 0xfa, 0xad, 0x3c, 0xe8, 0x9b, 0x79, 0xa0, 0xff, 0x7b, 0x03, 0x00, 0xef,
|
|
0x5d, 0x4d, 0x5d, 0xae, 0x16, 0x79, 0x30, 0x94, 0xd7, 0x80, 0x81, 0x72, 0xe6, 0x0b, 0x0d, 0x5c,
|
|
0x3d, 0xfa, 0x46, 0xcc, 0x26, 0xf5, 0xa2, 0x9a, 0xab, 0x17, 0xef, 0xc1, 0x86, 0xc4, 0xa7, 0x51,
|
|
0xcb, 0x68, 0x3d, 0xdb, 0x11, 0x22, 0x59, 0xa1, 0x18, 0xad, 0x56, 0x92, 0xa6, 0xbe, 0x9a, 0x34,
|
|
0x79, 0x34, 0x36, 0x8a, 0x68, 0x7c, 0x1b, 0x3a, 0x36, 0x67, 0x58, 0xbb, 0x26, 0xb2, 0x19, 0xd1,
|
|
0x68, 0x6d, 0x27, 0xc2, 0xb1, 0x3b, 0x67, 0x32, 0x7e, 0xf2, 0xe2, 0x00, 0x55, 0xf2, 0x73, 0xed,
|
|
0xbd, 0xb6, 0xd6, 0xde, 0x2b, 0x76, 0x02, 0x1e, 0xd3, 0x8c, 0x8f, 0xdf, 0xb9, 0xac, 0xe9, 0x14,
|
|
0xb2, 0xa6, 0x90, 0x1a, 0xdd, 0xa5, 0xd4, 0x58, 0xc2, 0x6f, 0x6f, 0x05, 0xbf, 0x6f, 0x41, 0x5b,
|
|
0x06, 0x20, 0x0a, 0xa9, 0xcd, 0xa4, 0x83, 0xbe, 0x0a, 0x44, 0x2a, 0x3b, 0x76, 0x30, 0xdb, 0xe3,
|
|
0xe9, 0x74, 0x71, 0x19, 0x78, 0x2c, 0x23, 0xec, 0x56, 0x2a, 0x3b, 0x76, 0xe4, 0x7e, 0x11, 0x81,
|
|
0x04, 0x11, 0x88, 0xdf, 0xc3, 0x0f, 0xa1, 0x99, 0x46, 0xfd, 0x3b, 0x81, 0xe9, 0x1f, 0x25, 0x68,
|
|
0xe7, 0x49, 0x51, 0x4e, 0x1e, 0x8f, 0x4f, 0x70, 0x72, 0xc5, 0x92, 0x9f, 0xb2, 0x9d, 0xe0, 0xcc,
|
|
0x67, 0xaf, 0xe8, 0xd4, 0x53, 0x0e, 0x1a, 0x56, 0x26, 0x90, 0x5a, 0xd7, 0xb7, 0x39, 0x9b, 0x27,
|
|
0xa8, 0xaa, 0x58, 0x99, 0x80, 0x7c, 0x04, 0xe0, 0x46, 0x51, 0xcc, 0xd4, 0xcd, 0x6d, 0x20, 0x65,
|
|
0x0c, 0x47, 0xaa, 0xc7, 0x1c, 0x25, 0x3d, 0xe6, 0x68, 0x9c, 0xf4, 0x98, 0x56, 0x13, 0xad, 0xf1,
|
|
0x4a, 0xef, 0x40, 0x4d, 0x5e, 0xd0, 0xf8, 0x04, 0x91, 0x57, 0xb1, 0xf4, 0xc8, 0xfc, 0x0b, 0xd4,
|
|
0x54, 0x17, 0xf2, 0x7f, 0x25, 0xfa, 0xbb, 0xd0, 0x50, 0xbe, 0x5d, 0x47, 0xe7, 0x4a, 0x1d, 0xc7,
|
|
0xc7, 0x8e, 0xf9, 0x75, 0x19, 0x1a, 0x16, 0x8b, 0xc2, 0xc0, 0x8f, 0x58, 0xae, 0x4b, 0x2a, 0x7d,
|
|
0x6b, 0x97, 0x54, 0x5e, 0xdb, 0x25, 0x25, 0xbd, 0x57, 0x25, 0xd7, 0x7b, 0x0d, 0xa1, 0xc1, 0x99,
|
|
0xe3, 0x72, 0x66, 0x0b, 0xdd, 0xa7, 0xa5, 0x63, 0xa9, 0x7b, 0x45, 0xb9, 0x2c, 0xef, 0x11, 0xd6,
|
|
0x90, 0xa6, 0x95, 0x8e, 0xc9, 0xe3, 0x7c, 0x73, 0xa1, 0xda, 0xb6, 0x2d, 0xd5, 0x5c, 0xa8, 0xed,
|
|
0xae, 0xe9, 0x2e, 0x9e, 0x64, 0x4d, 0x5a, 0x1d, 0xb3, 0xf9, 0x6e, 0x7e, 0xc2, 0xfa, 0x2e, 0xed,
|
|
0x7b, 0xab, 0xd9, 0x5f, 0x97, 0xa1, 0xbf, 0xbc, 0xb7, 0x35, 0x08, 0xdc, 0x82, 0xaa, 0xaa, 0x7d,
|
|
0x1a, 0xbe, 0x62, 0xa5, 0xea, 0x55, 0x96, 0x88, 0xee, 0x57, 0xcb, 0xa4, 0xf1, 0xed, 0xd0, 0x2b,
|
|
0x12, 0xca, 0xbb, 0xd0, 0x97, 0x21, 0x0a, 0x99, 0x93, 0xf5, 0x73, 0x8a, 0x01, 0x7b, 0x5a, 0x9e,
|
|
0x76, 0x74, 0xbb, 0x30, 0x48, 0x4c, 0x33, 0x6e, 0xa8, 0x15, 0x6c, 0x8f, 0x12, 0x8a, 0xb8, 0x03,
|
|
0xb5, 0x8b, 0x80, 0xcf, 0xa9, 0xd0, 0x24, 0xa8, 0x47, 0x05, 0x92, 0x43, 0xb6, 0x6d, 0x28, 0x4c,
|
|
0x26, 0x42, 0xf9, 0x66, 0x91, 0xe4, 0x93, 0xbe, 0x27, 0x90, 0x05, 0x1b, 0x56, 0x23, 0x79, 0x47,
|
|
0x98, 0xbf, 0x85, 0xde, 0x52, 0x0b, 0xb9, 0x26, 0x90, 0xd9, 0xf2, 0xe5, 0xc2, 0xf2, 0x05, 0xcf,
|
|
0x95, 0x25, 0xcf, 0xbf, 0x83, 0xc1, 0xa7, 0xd4, 0x77, 0x3c, 0xa6, 0xfd, 0x1f, 0xf0, 0x59, 0x24,
|
|
0x8b, 0xa1, 0x7e, 0xd1, 0x4c, 0x74, 0xf5, 0xe9, 0x58, 0x4d, 0x2d, 0x39, 0x76, 0xc8, 0x43, 0xa8,
|
|
0x73, 0x65, 0xad, 0x01, 0xd0, 0xca, 0xf5, 0xb8, 0x56, 0xa2, 0x33, 0xbf, 0x02, 0x52, 0x70, 0x2d,
|
|
0x1f, 0x33, 0x0b, 0xb2, 0x23, 0xd1, 0xaf, 0x40, 0xa1, 0xb3, 0xaa, 0x9d, 0xc7, 0xa4, 0x95, 0x6a,
|
|
0xc9, 0x36, 0x54, 0x18, 0xe7, 0x7a, 0x09, 0x6c, 0x32, 0xb3, 0xa7, 0xa3, 0x25, 0x55, 0x66, 0x1f,
|
|
0xba, 0xc7, 0xbe, 0x2b, 0x5c, 0xea, 0xb9, 0x7f, 0x66, 0x72, 0xe7, 0xe6, 0x13, 0xe8, 0x65, 0x12,
|
|
0xb5, 0xa0, 0x76, 0x53, 0xba, 0xdd, 0xcd, 0x4f, 0x60, 0x70, 0x1e, 0x32, 0xdb, 0xa5, 0x1e, 0xbe,
|
|
0x1e, 0xd5, 0xb4, 0x07, 0x50, 0x95, 0x77, 0x95, 0xf0, 0x4e, 0x13, 0x27, 0xa2, 0x5a, 0xc9, 0xcd,
|
|
0xaf, 0xc0, 0x50, 0xc7, 0x3b, 0xba, 0x71, 0x23, 0xc1, 0x7c, 0x9b, 0x1d, 0x5e, 0x32, 0xfb, 0xea,
|
|
0x7b, 0x0c, 0xe0, 0x35, 0xdc, 0x5d, 0xb7, 0x42, 0xb2, 0xbf, 0x96, 0x2d, 0x47, 0x93, 0x0b, 0x59,
|
|
0x82, 0x70, 0x8d, 0x86, 0x05, 0x28, 0xfa, 0x44, 0x4a, 0x24, 0x1c, 0x98, 0x9c, 0x17, 0x69, 0x5a,
|
|
0xd7, 0xa3, 0x24, 0x1e, 0x95, 0xdb, 0xe3, 0xf1, 0xcf, 0x12, 0x34, 0xcf, 0x99, 0x88, 0x43, 0x3c,
|
|
0xcb, 0x3d, 0x68, 0x4e, 0x79, 0x70, 0xc5, 0x78, 0x76, 0x94, 0x86, 0x12, 0x1c, 0x3b, 0xe4, 0x31,
|
|
0xd4, 0x0e, 0x03, 0xff, 0xc2, 0x9d, 0xe1, 0x5b, 0x5a, 0xf3, 0x4b, 0x3a, 0x77, 0xa4, 0x74, 0x8a,
|
|
0x5f, 0xb4, 0x21, 0xd9, 0x86, 0x96, 0xfe, 0x65, 0xe2, 0xe5, 0xcb, 0xe3, 0xe7, 0x49, 0x93, 0x9d,
|
|
0x13, 0x0d, 0x3f, 0x82, 0x56, 0x6e, 0xe2, 0x77, 0xaa, 0x78, 0x3f, 0x04, 0xc0, 0xd5, 0x55, 0x8c,
|
|
0xfa, 0xd9, 0xd5, 0x37, 0xd5, 0xd1, 0x1e, 0x40, 0x53, 0xf6, 0x73, 0x4a, 0x9d, 0xd4, 0xda, 0x52,
|
|
0x56, 0x6b, 0xcd, 0x87, 0x30, 0x38, 0xf6, 0xaf, 0xa9, 0xe7, 0x3a, 0x54, 0xb0, 0xcf, 0xd8, 0x02,
|
|
0x43, 0xb0, 0xb2, 0x03, 0xf3, 0x1c, 0xda, 0xfa, 0x71, 0xff, 0x5a, 0x7b, 0x6c, 0xeb, 0x3d, 0x7e,
|
|
0x73, 0x2e, 0xbe, 0x0b, 0x3d, 0xed, 0xf4, 0xc4, 0xd5, 0x99, 0x28, 0x5b, 0x15, 0xce, 0x2e, 0xdc,
|
|
0x1b, 0xed, 0x5a, 0x8f, 0xcc, 0x67, 0xd0, 0xcf, 0x99, 0xa6, 0xc7, 0xb9, 0x62, 0x8b, 0x28, 0xf9,
|
|
0xd1, 0x43, 0x7e, 0x27, 0x11, 0x28, 0x67, 0x11, 0x30, 0xa1, 0xab, 0x67, 0xbe, 0x60, 0xe2, 0x96,
|
|
0xd3, 0x7d, 0x96, 0x6e, 0xe4, 0x05, 0xd3, 0xce, 0x1f, 0x41, 0x95, 0xc9, 0x93, 0xe6, 0xcb, 0x70,
|
|
0x3e, 0x02, 0x96, 0x52, 0xaf, 0x59, 0xf0, 0x59, 0xba, 0xe0, 0x59, 0xac, 0x16, 0x7c, 0x4d, 0x5f,
|
|
0xe6, 0xdb, 0xe9, 0x36, 0xce, 0x62, 0x71, 0xdb, 0x8d, 0x3e, 0x84, 0x81, 0x36, 0x7a, 0xce, 0x3c,
|
|
0x26, 0xd8, 0x2d, 0x47, 0x7a, 0x04, 0xa4, 0x60, 0x76, 0x9b, 0xbb, 0xfb, 0xd0, 0x18, 0x8f, 0x4f,
|
|
0x52, 0x6d, 0x91, 0x62, 0xcd, 0x1d, 0x68, 0x8f, 0xa9, 0x6c, 0x25, 0x1c, 0x65, 0x61, 0x40, 0x5d,
|
|
0xa8, 0xb1, 0x4e, 0xc0, 0x64, 0x68, 0xee, 0xc3, 0xd6, 0x21, 0xb5, 0x2f, 0x5d, 0x7f, 0xf6, 0xdc,
|
|
0x8d, 0x64, 0x2f, 0xa5, 0x67, 0x0c, 0xa1, 0xe1, 0x68, 0x81, 0x9e, 0x92, 0x8e, 0xcd, 0xf7, 0xe1,
|
|
0x8d, 0xdc, 0x0f, 0x3e, 0xe7, 0x82, 0x26, 0xdb, 0xdc, 0x82, 0x6a, 0x24, 0x47, 0x38, 0xa3, 0x6a,
|
|
0xa9, 0x81, 0xf9, 0x39, 0x6c, 0xe5, 0xcb, 0xab, 0xec, 0x6c, 0xf0, 0xf0, 0x49, 0xcf, 0x51, 0xca,
|
|
0xf5, 0x1c, 0xfa, 0x28, 0xe5, 0xac, 0x5a, 0xf4, 0xa1, 0xf2, 0xeb, 0x2f, 0xc7, 0x1a, 0x83, 0xf2,
|
|
0xd3, 0xfc, 0xa3, 0x5c, 0xbe, 0xe8, 0x4f, 0x2d, 0x5f, 0x68, 0x3c, 0x4a, 0xaf, 0xd5, 0x78, 0xac,
|
|
0xc2, 0xe0, 0x7d, 0x18, 0x9c, 0x7a, 0x81, 0x7d, 0x75, 0xe4, 0xe7, 0xa2, 0x61, 0x40, 0x9d, 0xf9,
|
|
0xf9, 0x60, 0x24, 0x43, 0xf3, 0x1d, 0xe8, 0x9d, 0x04, 0x36, 0xf5, 0x4e, 0x83, 0xd8, 0x17, 0x69,
|
|
0x14, 0xf0, 0x17, 0x38, 0x6d, 0xaa, 0x06, 0xe6, 0xfb, 0xd0, 0xd5, 0x05, 0xd8, 0xbf, 0x08, 0x12,
|
|
0xc2, 0xca, 0x4a, 0x75, 0xa9, 0xd8, 0xc6, 0x9b, 0x27, 0xd0, 0xcb, 0xcc, 0x95, 0xdf, 0x77, 0xa0,
|
|
0xa6, 0xd4, 0xfa, 0x6c, 0xbd, 0xf4, 0x1d, 0xab, 0x2c, 0x2d, 0xad, 0x5e, 0x73, 0xa8, 0x39, 0x74,
|
|
0xcf, 0xf0, 0x97, 0xd0, 0x23, 0xff, 0x5a, 0x39, 0x3b, 0x06, 0xa2, 0x7e, 0x1b, 0x9d, 0x30, 0xff,
|
|
0xda, 0xe5, 0x81, 0x8f, 0xad, 0x73, 0x49, 0x37, 0x28, 0x89, 0xe3, 0x74, 0x52, 0x62, 0x61, 0x0d,
|
|
0xc2, 0x65, 0xd1, 0xda, 0x18, 0x42, 0xf6, 0x3b, 0x8b, 0xac, 0x00, 0x9c, 0xcd, 0x03, 0xc1, 0x26,
|
|
0xd4, 0x71, 0x12, 0x10, 0x83, 0x12, 0x1d, 0x38, 0x0e, 0xdf, 0xff, 0x7b, 0x05, 0xea, 0x1f, 0x2b,
|
|
0x5e, 0x25, 0xbf, 0x84, 0x4e, 0xa1, 0x18, 0x93, 0x37, 0xb0, 0x69, 0x5b, 0x2e, 0xfd, 0xc3, 0x3b,
|
|
0x2b, 0x62, 0x75, 0xae, 0x0f, 0xa0, 0x9d, 0xaf, 0x91, 0x04, 0xeb, 0x21, 0xfe, 0xea, 0x3b, 0x44,
|
|
0x4f, 0xab, 0x05, 0xf4, 0x1c, 0xb6, 0xd6, 0x55, 0x2f, 0x72, 0x3f, 0x5b, 0x61, 0xb5, 0x72, 0x0e,
|
|
0xdf, 0xbc, 0x4d, 0x9b, 0x54, 0xbd, 0xfa, 0xa1, 0xc7, 0xa8, 0x1f, 0x87, 0xf9, 0x1d, 0x64, 0x9f,
|
|
0xe4, 0x31, 0x74, 0x0a, 0xfc, 0xad, 0xce, 0xb9, 0x42, 0xe9, 0xf9, 0x29, 0x8f, 0xa0, 0x8a, 0x35,
|
|
0x83, 0x74, 0x0a, 0xc5, 0x6b, 0xd8, 0x4d, 0x87, 0x6a, 0xed, 0xa7, 0x00, 0x59, 0x6f, 0x41, 0x88,
|
|
0xf2, 0x9b, 0xef, 0x3e, 0x86, 0x9b, 0x45, 0x59, 0xd2, 0x7f, 0x6c, 0xe0, 0x4f, 0x08, 0xb9, 0xfd,
|
|
0xe2, 0x42, 0x69, 0x1d, 0xda, 0xff, 0x4f, 0x09, 0xea, 0xc9, 0xcf, 0xca, 0x8f, 0x61, 0x43, 0x32,
|
|
0x3a, 0xd9, 0xcc, 0x91, 0x62, 0x52, 0x0d, 0x86, 0x5b, 0x4b, 0x42, 0xb5, 0xc0, 0x08, 0x2a, 0x2f,
|
|
0x98, 0x50, 0x1b, 0x2a, 0x52, 0xfb, 0x70, 0xb3, 0x28, 0x4b, 0xed, 0xcf, 0xe2, 0xa2, 0xbd, 0x66,
|
|
0xe6, 0x82, 0x7d, 0xca, 0xb9, 0x1f, 0x42, 0x4d, 0x71, 0xa6, 0x8a, 0xe5, 0x0a, 0xdb, 0x2a, 0xcc,
|
|
0xac, 0xb2, 0xeb, 0xfe, 0x5f, 0x37, 0x00, 0xce, 0x17, 0x91, 0x60, 0xf3, 0xdf, 0xb8, 0xec, 0x15,
|
|
0xd9, 0x85, 0x9e, 0xfe, 0xa1, 0x04, 0xdf, 0x6f, 0x92, 0x84, 0x72, 0x31, 0xc1, 0x2e, 0x30, 0xa5,
|
|
0xde, 0x47, 0xd0, 0x3a, 0xa5, 0x37, 0xaf, 0x63, 0x57, 0xd7, 0x84, 0x9c, 0xb7, 0xc1, 0x8a, 0x52,
|
|
0x20, 0xea, 0x9f, 0x42, 0x6f, 0x89, 0x8e, 0xf3, 0xf6, 0xf8, 0x1b, 0xc7, 0x5a, 0xba, 0x7e, 0x26,
|
|
0x9f, 0x30, 0x45, 0x4a, 0xce, 0x4f, 0xd4, 0xcf, 0xa9, 0x75, 0x9c, 0xfd, 0xa2, 0xf8, 0xf8, 0xc1,
|
|
0x77, 0xa7, 0xb1, 0xcc, 0x9a, 0x09, 0x67, 0x0f, 0xef, 0xae, 0xd3, 0xa4, 0x99, 0x97, 0x27, 0xce,
|
|
0x95, 0xcc, 0x5b, 0x65, 0xd5, 0xf7, 0x00, 0x32, 0xee, 0xcc, 0xdb, 0xe3, 0xf5, 0x2e, 0xd3, 0xea,
|
|
0x53, 0x80, 0x8c, 0x11, 0x15, 0x2a, 0x8a, 0x84, 0xaa, 0xa6, 0x2d, 0xb3, 0xe6, 0x2e, 0x34, 0x53,
|
|
0x16, 0xcb, 0xaf, 0x81, 0x0e, 0x8a, 0xa4, 0xf8, 0xf1, 0xee, 0xef, 0x77, 0x66, 0xae, 0xb8, 0x8c,
|
|
0xa7, 0x23, 0x3b, 0x98, 0xef, 0x5d, 0xd2, 0xe8, 0xd2, 0xb5, 0x03, 0x1e, 0xee, 0x5d, 0x4b, 0x30,
|
|
0xec, 0x15, 0xfe, 0xb5, 0x9a, 0xd6, 0xf0, 0xf5, 0xf6, 0xe4, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff,
|
|
0x66, 0x13, 0x8f, 0x1a, 0xcd, 0x1a, 0x00, 0x00,
|
|
}
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ context.Context
|
|
var _ grpc.ClientConn
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
const _ = grpc.SupportPackageIsVersion4
|
|
|
|
// BackendClient is the client API for Backend service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type BackendClient interface {
|
|
// HandleRequest is used to handle a request and generate a response.
|
|
// The plugins must check the operation type and handle appropriately.
|
|
HandleRequest(ctx context.Context, in *HandleRequestArgs, opts ...grpc.CallOption) (*HandleRequestReply, error)
|
|
// SpecialPaths is a list of paths that are special in some way.
|
|
// See PathType for the types of special paths. The key is the type
|
|
// of the special path, and the value is a list of paths for this type.
|
|
// This is not a regular expression but is an exact match. If the path
|
|
// ends in '*' then it is a prefix-based match. The '*' can only appear
|
|
// at the end.
|
|
SpecialPaths(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SpecialPathsReply, error)
|
|
// HandleExistenceCheck is used to handle a request and generate a response
|
|
// indicating whether the given path exists or not; this is used to
|
|
// understand whether the request must have a Create or Update capability
|
|
// ACL applied. The first bool indicates whether an existence check
|
|
// function was found for the backend; the second indicates whether, if an
|
|
// existence check function was found, the item exists or not.
|
|
HandleExistenceCheck(ctx context.Context, in *HandleExistenceCheckArgs, opts ...grpc.CallOption) (*HandleExistenceCheckReply, error)
|
|
// Cleanup is invoked during an unmount of a backend to allow it to
|
|
// handle any cleanup like connection closing or releasing of file handles.
|
|
// Cleanup is called right before Vault closes the plugin process.
|
|
Cleanup(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
|
|
// InvalidateKey may be invoked when an object is modified that belongs
|
|
// to the backend. The backend can use this to clear any caches or reset
|
|
// internal state as needed.
|
|
InvalidateKey(ctx context.Context, in *InvalidateKeyArgs, opts ...grpc.CallOption) (*Empty, error)
|
|
// Setup is used to set up the backend based on the provided backend
|
|
// configuration. The plugin's setup implementation should use the provided
|
|
// broker_id to create a connection back to Vault for use with the Storage
|
|
// and SystemView clients.
|
|
Setup(ctx context.Context, in *SetupArgs, opts ...grpc.CallOption) (*SetupReply, error)
|
|
// Initialize is invoked just after mounting a backend to allow it to
|
|
// handle any initialization tasks that need to be performed.
|
|
Initialize(ctx context.Context, in *InitializeArgs, opts ...grpc.CallOption) (*InitializeReply, error)
|
|
// Type returns the BackendType for the particular backend
|
|
Type(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TypeReply, error)
|
|
}
|
|
|
|
type backendClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewBackendClient(cc *grpc.ClientConn) BackendClient {
|
|
return &backendClient{cc}
|
|
}
|
|
|
|
func (c *backendClient) HandleRequest(ctx context.Context, in *HandleRequestArgs, opts ...grpc.CallOption) (*HandleRequestReply, error) {
|
|
out := new(HandleRequestReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/HandleRequest", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) SpecialPaths(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SpecialPathsReply, error) {
|
|
out := new(SpecialPathsReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/SpecialPaths", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) HandleExistenceCheck(ctx context.Context, in *HandleExistenceCheckArgs, opts ...grpc.CallOption) (*HandleExistenceCheckReply, error) {
|
|
out := new(HandleExistenceCheckReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/HandleExistenceCheck", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) Cleanup(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
|
|
out := new(Empty)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/Cleanup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) InvalidateKey(ctx context.Context, in *InvalidateKeyArgs, opts ...grpc.CallOption) (*Empty, error) {
|
|
out := new(Empty)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/InvalidateKey", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) Setup(ctx context.Context, in *SetupArgs, opts ...grpc.CallOption) (*SetupReply, error) {
|
|
out := new(SetupReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/Setup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) Initialize(ctx context.Context, in *InitializeArgs, opts ...grpc.CallOption) (*InitializeReply, error) {
|
|
out := new(InitializeReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/Initialize", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *backendClient) Type(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TypeReply, error) {
|
|
out := new(TypeReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Backend/Type", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// BackendServer is the server API for Backend service.
|
|
type BackendServer interface {
|
|
// HandleRequest is used to handle a request and generate a response.
|
|
// The plugins must check the operation type and handle appropriately.
|
|
HandleRequest(context.Context, *HandleRequestArgs) (*HandleRequestReply, error)
|
|
// SpecialPaths is a list of paths that are special in some way.
|
|
// See PathType for the types of special paths. The key is the type
|
|
// of the special path, and the value is a list of paths for this type.
|
|
// This is not a regular expression but is an exact match. If the path
|
|
// ends in '*' then it is a prefix-based match. The '*' can only appear
|
|
// at the end.
|
|
SpecialPaths(context.Context, *Empty) (*SpecialPathsReply, error)
|
|
// HandleExistenceCheck is used to handle a request and generate a response
|
|
// indicating whether the given path exists or not; this is used to
|
|
// understand whether the request must have a Create or Update capability
|
|
// ACL applied. The first bool indicates whether an existence check
|
|
// function was found for the backend; the second indicates whether, if an
|
|
// existence check function was found, the item exists or not.
|
|
HandleExistenceCheck(context.Context, *HandleExistenceCheckArgs) (*HandleExistenceCheckReply, error)
|
|
// Cleanup is invoked during an unmount of a backend to allow it to
|
|
// handle any cleanup like connection closing or releasing of file handles.
|
|
// Cleanup is called right before Vault closes the plugin process.
|
|
Cleanup(context.Context, *Empty) (*Empty, error)
|
|
// InvalidateKey may be invoked when an object is modified that belongs
|
|
// to the backend. The backend can use this to clear any caches or reset
|
|
// internal state as needed.
|
|
InvalidateKey(context.Context, *InvalidateKeyArgs) (*Empty, error)
|
|
// Setup is used to set up the backend based on the provided backend
|
|
// configuration. The plugin's setup implementation should use the provided
|
|
// broker_id to create a connection back to Vault for use with the Storage
|
|
// and SystemView clients.
|
|
Setup(context.Context, *SetupArgs) (*SetupReply, error)
|
|
// Initialize is invoked just after mounting a backend to allow it to
|
|
// handle any initialization tasks that need to be performed.
|
|
Initialize(context.Context, *InitializeArgs) (*InitializeReply, error)
|
|
// Type returns the BackendType for the particular backend
|
|
Type(context.Context, *Empty) (*TypeReply, error)
|
|
}
|
|
|
|
// UnimplementedBackendServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedBackendServer struct {
|
|
}
|
|
|
|
func (*UnimplementedBackendServer) HandleRequest(ctx context.Context, req *HandleRequestArgs) (*HandleRequestReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method HandleRequest not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) SpecialPaths(ctx context.Context, req *Empty) (*SpecialPathsReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SpecialPaths not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) HandleExistenceCheck(ctx context.Context, req *HandleExistenceCheckArgs) (*HandleExistenceCheckReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method HandleExistenceCheck not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) Cleanup(ctx context.Context, req *Empty) (*Empty, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Cleanup not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) InvalidateKey(ctx context.Context, req *InvalidateKeyArgs) (*Empty, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method InvalidateKey not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) Setup(ctx context.Context, req *SetupArgs) (*SetupReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Setup not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) Initialize(ctx context.Context, req *InitializeArgs) (*InitializeReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Initialize not implemented")
|
|
}
|
|
func (*UnimplementedBackendServer) Type(ctx context.Context, req *Empty) (*TypeReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Type not implemented")
|
|
}
|
|
|
|
func RegisterBackendServer(s *grpc.Server, srv BackendServer) {
|
|
s.RegisterService(&_Backend_serviceDesc, srv)
|
|
}
|
|
|
|
func _Backend_HandleRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HandleRequestArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).HandleRequest(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/HandleRequest",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).HandleRequest(ctx, req.(*HandleRequestArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_SpecialPaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).SpecialPaths(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/SpecialPaths",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).SpecialPaths(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_HandleExistenceCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HandleExistenceCheckArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).HandleExistenceCheck(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/HandleExistenceCheck",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).HandleExistenceCheck(ctx, req.(*HandleExistenceCheckArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).Cleanup(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/Cleanup",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).Cleanup(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_InvalidateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(InvalidateKeyArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).InvalidateKey(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/InvalidateKey",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).InvalidateKey(ctx, req.(*InvalidateKeyArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_Setup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetupArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).Setup(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/Setup",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).Setup(ctx, req.(*SetupArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_Initialize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(InitializeArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).Initialize(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/Initialize",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).Initialize(ctx, req.(*InitializeArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Backend_Type_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(BackendServer).Type(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Backend/Type",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(BackendServer).Type(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _Backend_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "pb.Backend",
|
|
HandlerType: (*BackendServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "HandleRequest",
|
|
Handler: _Backend_HandleRequest_Handler,
|
|
},
|
|
{
|
|
MethodName: "SpecialPaths",
|
|
Handler: _Backend_SpecialPaths_Handler,
|
|
},
|
|
{
|
|
MethodName: "HandleExistenceCheck",
|
|
Handler: _Backend_HandleExistenceCheck_Handler,
|
|
},
|
|
{
|
|
MethodName: "Cleanup",
|
|
Handler: _Backend_Cleanup_Handler,
|
|
},
|
|
{
|
|
MethodName: "InvalidateKey",
|
|
Handler: _Backend_InvalidateKey_Handler,
|
|
},
|
|
{
|
|
MethodName: "Setup",
|
|
Handler: _Backend_Setup_Handler,
|
|
},
|
|
{
|
|
MethodName: "Initialize",
|
|
Handler: _Backend_Initialize_Handler,
|
|
},
|
|
{
|
|
MethodName: "Type",
|
|
Handler: _Backend_Type_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "sdk/plugin/pb/backend.proto",
|
|
}
|
|
|
|
// StorageClient is the client API for Storage service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type StorageClient interface {
|
|
List(ctx context.Context, in *StorageListArgs, opts ...grpc.CallOption) (*StorageListReply, error)
|
|
Get(ctx context.Context, in *StorageGetArgs, opts ...grpc.CallOption) (*StorageGetReply, error)
|
|
Put(ctx context.Context, in *StoragePutArgs, opts ...grpc.CallOption) (*StoragePutReply, error)
|
|
Delete(ctx context.Context, in *StorageDeleteArgs, opts ...grpc.CallOption) (*StorageDeleteReply, error)
|
|
}
|
|
|
|
type storageClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewStorageClient(cc *grpc.ClientConn) StorageClient {
|
|
return &storageClient{cc}
|
|
}
|
|
|
|
func (c *storageClient) List(ctx context.Context, in *StorageListArgs, opts ...grpc.CallOption) (*StorageListReply, error) {
|
|
out := new(StorageListReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Storage/List", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *storageClient) Get(ctx context.Context, in *StorageGetArgs, opts ...grpc.CallOption) (*StorageGetReply, error) {
|
|
out := new(StorageGetReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Storage/Get", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *storageClient) Put(ctx context.Context, in *StoragePutArgs, opts ...grpc.CallOption) (*StoragePutReply, error) {
|
|
out := new(StoragePutReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Storage/Put", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *storageClient) Delete(ctx context.Context, in *StorageDeleteArgs, opts ...grpc.CallOption) (*StorageDeleteReply, error) {
|
|
out := new(StorageDeleteReply)
|
|
err := c.cc.Invoke(ctx, "/pb.Storage/Delete", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// StorageServer is the server API for Storage service.
|
|
type StorageServer interface {
|
|
List(context.Context, *StorageListArgs) (*StorageListReply, error)
|
|
Get(context.Context, *StorageGetArgs) (*StorageGetReply, error)
|
|
Put(context.Context, *StoragePutArgs) (*StoragePutReply, error)
|
|
Delete(context.Context, *StorageDeleteArgs) (*StorageDeleteReply, error)
|
|
}
|
|
|
|
// UnimplementedStorageServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedStorageServer struct {
|
|
}
|
|
|
|
func (*UnimplementedStorageServer) List(ctx context.Context, req *StorageListArgs) (*StorageListReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
|
|
}
|
|
func (*UnimplementedStorageServer) Get(ctx context.Context, req *StorageGetArgs) (*StorageGetReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
|
|
}
|
|
func (*UnimplementedStorageServer) Put(ctx context.Context, req *StoragePutArgs) (*StoragePutReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Put not implemented")
|
|
}
|
|
func (*UnimplementedStorageServer) Delete(ctx context.Context, req *StorageDeleteArgs) (*StorageDeleteReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
|
|
}
|
|
|
|
func RegisterStorageServer(s *grpc.Server, srv StorageServer) {
|
|
s.RegisterService(&_Storage_serviceDesc, srv)
|
|
}
|
|
|
|
func _Storage_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StorageListArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(StorageServer).List(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Storage/List",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(StorageServer).List(ctx, req.(*StorageListArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Storage_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StorageGetArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(StorageServer).Get(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Storage/Get",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(StorageServer).Get(ctx, req.(*StorageGetArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Storage_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StoragePutArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(StorageServer).Put(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Storage/Put",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(StorageServer).Put(ctx, req.(*StoragePutArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Storage_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StorageDeleteArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(StorageServer).Delete(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.Storage/Delete",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(StorageServer).Delete(ctx, req.(*StorageDeleteArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _Storage_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "pb.Storage",
|
|
HandlerType: (*StorageServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "List",
|
|
Handler: _Storage_List_Handler,
|
|
},
|
|
{
|
|
MethodName: "Get",
|
|
Handler: _Storage_Get_Handler,
|
|
},
|
|
{
|
|
MethodName: "Put",
|
|
Handler: _Storage_Put_Handler,
|
|
},
|
|
{
|
|
MethodName: "Delete",
|
|
Handler: _Storage_Delete_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "sdk/plugin/pb/backend.proto",
|
|
}
|
|
|
|
// SystemViewClient is the client API for SystemView service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type SystemViewClient interface {
|
|
// DefaultLeaseTTL returns the default lease TTL set in Vault configuration
|
|
DefaultLeaseTTL(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TTLReply, error)
|
|
// MaxLeaseTTL returns the max lease TTL set in Vault configuration; backend
|
|
// authors should take care not to issue credentials that last longer than
|
|
// this value, as Vault will revoke them
|
|
MaxLeaseTTL(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TTLReply, error)
|
|
// Tainted, returns true if the mount is tainted. A mount is tainted if it is in the
|
|
// process of being unmounted. This should only be used in special
|
|
// circumstances; a primary use-case is as a guard in revocation functions.
|
|
// If revocation of a backend's leases fails it can keep the unmounting
|
|
// process from being successful. If the reason for this failure is not
|
|
// relevant when the mount is tainted (for instance, saving a CRL to disk
|
|
// when the stored CRL will be removed during the unmounting process
|
|
// anyways), we can ignore the errors to allow unmounting to complete.
|
|
Tainted(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TaintedReply, error)
|
|
// CachingDisabled returns true if caching is disabled. If true, no caches
|
|
// should be used, despite known slowdowns.
|
|
CachingDisabled(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*CachingDisabledReply, error)
|
|
// ReplicationState indicates the state of cluster replication
|
|
ReplicationState(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ReplicationStateReply, error)
|
|
// ResponseWrapData wraps the given data in a cubbyhole and returns the
|
|
// token used to unwrap.
|
|
ResponseWrapData(ctx context.Context, in *ResponseWrapDataArgs, opts ...grpc.CallOption) (*ResponseWrapDataReply, error)
|
|
// MlockEnabled returns the configuration setting for enabling mlock on
|
|
// plugins.
|
|
MlockEnabled(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MlockEnabledReply, error)
|
|
// LocalMount, when run from a system view attached to a request, indicates
|
|
// whether the request is affecting a local mount or not
|
|
LocalMount(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*LocalMountReply, error)
|
|
// EntityInfo returns the basic entity information for the given entity id
|
|
EntityInfo(ctx context.Context, in *EntityInfoArgs, opts ...grpc.CallOption) (*EntityInfoReply, error)
|
|
// PluginEnv returns Vault environment information used by plugins
|
|
PluginEnv(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PluginEnvReply, error)
|
|
}
|
|
|
|
type systemViewClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewSystemViewClient(cc *grpc.ClientConn) SystemViewClient {
|
|
return &systemViewClient{cc}
|
|
}
|
|
|
|
func (c *systemViewClient) DefaultLeaseTTL(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TTLReply, error) {
|
|
out := new(TTLReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/DefaultLeaseTTL", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) MaxLeaseTTL(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TTLReply, error) {
|
|
out := new(TTLReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/MaxLeaseTTL", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) Tainted(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*TaintedReply, error) {
|
|
out := new(TaintedReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/Tainted", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) CachingDisabled(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*CachingDisabledReply, error) {
|
|
out := new(CachingDisabledReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/CachingDisabled", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) ReplicationState(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ReplicationStateReply, error) {
|
|
out := new(ReplicationStateReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/ReplicationState", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) ResponseWrapData(ctx context.Context, in *ResponseWrapDataArgs, opts ...grpc.CallOption) (*ResponseWrapDataReply, error) {
|
|
out := new(ResponseWrapDataReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/ResponseWrapData", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) MlockEnabled(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MlockEnabledReply, error) {
|
|
out := new(MlockEnabledReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/MlockEnabled", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) LocalMount(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*LocalMountReply, error) {
|
|
out := new(LocalMountReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/LocalMount", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) EntityInfo(ctx context.Context, in *EntityInfoArgs, opts ...grpc.CallOption) (*EntityInfoReply, error) {
|
|
out := new(EntityInfoReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/EntityInfo", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *systemViewClient) PluginEnv(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PluginEnvReply, error) {
|
|
out := new(PluginEnvReply)
|
|
err := c.cc.Invoke(ctx, "/pb.SystemView/PluginEnv", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// SystemViewServer is the server API for SystemView service.
|
|
type SystemViewServer interface {
|
|
// DefaultLeaseTTL returns the default lease TTL set in Vault configuration
|
|
DefaultLeaseTTL(context.Context, *Empty) (*TTLReply, error)
|
|
// MaxLeaseTTL returns the max lease TTL set in Vault configuration; backend
|
|
// authors should take care not to issue credentials that last longer than
|
|
// this value, as Vault will revoke them
|
|
MaxLeaseTTL(context.Context, *Empty) (*TTLReply, error)
|
|
// Tainted, returns true if the mount is tainted. A mount is tainted if it is in the
|
|
// process of being unmounted. This should only be used in special
|
|
// circumstances; a primary use-case is as a guard in revocation functions.
|
|
// If revocation of a backend's leases fails it can keep the unmounting
|
|
// process from being successful. If the reason for this failure is not
|
|
// relevant when the mount is tainted (for instance, saving a CRL to disk
|
|
// when the stored CRL will be removed during the unmounting process
|
|
// anyways), we can ignore the errors to allow unmounting to complete.
|
|
Tainted(context.Context, *Empty) (*TaintedReply, error)
|
|
// CachingDisabled returns true if caching is disabled. If true, no caches
|
|
// should be used, despite known slowdowns.
|
|
CachingDisabled(context.Context, *Empty) (*CachingDisabledReply, error)
|
|
// ReplicationState indicates the state of cluster replication
|
|
ReplicationState(context.Context, *Empty) (*ReplicationStateReply, error)
|
|
// ResponseWrapData wraps the given data in a cubbyhole and returns the
|
|
// token used to unwrap.
|
|
ResponseWrapData(context.Context, *ResponseWrapDataArgs) (*ResponseWrapDataReply, error)
|
|
// MlockEnabled returns the configuration setting for enabling mlock on
|
|
// plugins.
|
|
MlockEnabled(context.Context, *Empty) (*MlockEnabledReply, error)
|
|
// LocalMount, when run from a system view attached to a request, indicates
|
|
// whether the request is affecting a local mount or not
|
|
LocalMount(context.Context, *Empty) (*LocalMountReply, error)
|
|
// EntityInfo returns the basic entity information for the given entity id
|
|
EntityInfo(context.Context, *EntityInfoArgs) (*EntityInfoReply, error)
|
|
// PluginEnv returns Vault environment information used by plugins
|
|
PluginEnv(context.Context, *Empty) (*PluginEnvReply, error)
|
|
}
|
|
|
|
// UnimplementedSystemViewServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedSystemViewServer struct {
|
|
}
|
|
|
|
func (*UnimplementedSystemViewServer) DefaultLeaseTTL(ctx context.Context, req *Empty) (*TTLReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method DefaultLeaseTTL not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) MaxLeaseTTL(ctx context.Context, req *Empty) (*TTLReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method MaxLeaseTTL not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) Tainted(ctx context.Context, req *Empty) (*TaintedReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Tainted not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) CachingDisabled(ctx context.Context, req *Empty) (*CachingDisabledReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method CachingDisabled not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) ReplicationState(ctx context.Context, req *Empty) (*ReplicationStateReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ReplicationState not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) ResponseWrapData(ctx context.Context, req *ResponseWrapDataArgs) (*ResponseWrapDataReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ResponseWrapData not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) MlockEnabled(ctx context.Context, req *Empty) (*MlockEnabledReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method MlockEnabled not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) LocalMount(ctx context.Context, req *Empty) (*LocalMountReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method LocalMount not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) EntityInfo(ctx context.Context, req *EntityInfoArgs) (*EntityInfoReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method EntityInfo not implemented")
|
|
}
|
|
func (*UnimplementedSystemViewServer) PluginEnv(ctx context.Context, req *Empty) (*PluginEnvReply, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method PluginEnv not implemented")
|
|
}
|
|
|
|
func RegisterSystemViewServer(s *grpc.Server, srv SystemViewServer) {
|
|
s.RegisterService(&_SystemView_serviceDesc, srv)
|
|
}
|
|
|
|
func _SystemView_DefaultLeaseTTL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).DefaultLeaseTTL(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/DefaultLeaseTTL",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).DefaultLeaseTTL(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_MaxLeaseTTL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).MaxLeaseTTL(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/MaxLeaseTTL",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).MaxLeaseTTL(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_Tainted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).Tainted(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/Tainted",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).Tainted(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_CachingDisabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).CachingDisabled(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/CachingDisabled",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).CachingDisabled(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_ReplicationState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).ReplicationState(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/ReplicationState",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).ReplicationState(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_ResponseWrapData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ResponseWrapDataArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).ResponseWrapData(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/ResponseWrapData",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).ResponseWrapData(ctx, req.(*ResponseWrapDataArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_MlockEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).MlockEnabled(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/MlockEnabled",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).MlockEnabled(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_LocalMount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).LocalMount(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/LocalMount",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).LocalMount(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_EntityInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EntityInfoArgs)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).EntityInfo(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/EntityInfo",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).EntityInfo(ctx, req.(*EntityInfoArgs))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _SystemView_PluginEnv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(SystemViewServer).PluginEnv(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/pb.SystemView/PluginEnv",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(SystemViewServer).PluginEnv(ctx, req.(*Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _SystemView_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "pb.SystemView",
|
|
HandlerType: (*SystemViewServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "DefaultLeaseTTL",
|
|
Handler: _SystemView_DefaultLeaseTTL_Handler,
|
|
},
|
|
{
|
|
MethodName: "MaxLeaseTTL",
|
|
Handler: _SystemView_MaxLeaseTTL_Handler,
|
|
},
|
|
{
|
|
MethodName: "Tainted",
|
|
Handler: _SystemView_Tainted_Handler,
|
|
},
|
|
{
|
|
MethodName: "CachingDisabled",
|
|
Handler: _SystemView_CachingDisabled_Handler,
|
|
},
|
|
{
|
|
MethodName: "ReplicationState",
|
|
Handler: _SystemView_ReplicationState_Handler,
|
|
},
|
|
{
|
|
MethodName: "ResponseWrapData",
|
|
Handler: _SystemView_ResponseWrapData_Handler,
|
|
},
|
|
{
|
|
MethodName: "MlockEnabled",
|
|
Handler: _SystemView_MlockEnabled_Handler,
|
|
},
|
|
{
|
|
MethodName: "LocalMount",
|
|
Handler: _SystemView_LocalMount_Handler,
|
|
},
|
|
{
|
|
MethodName: "EntityInfo",
|
|
Handler: _SystemView_EntityInfo_Handler,
|
|
},
|
|
{
|
|
MethodName: "PluginEnv",
|
|
Handler: _SystemView_PluginEnv_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "sdk/plugin/pb/backend.proto",
|
|
}
|