generated

package
v0.0.1-dev.45 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 13, 2026 License: MIT Imports: 16 Imported by: 0

Documentation

Overview

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package generated is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

View Source 
const (
	AdminService_AdminBootstrap_FullMethodName          = "/rune.api.AdminService/AdminBootstrap"
	AdminService_PolicyCreate_FullMethodName            = "/rune.api.AdminService/PolicyCreate"
	AdminService_PolicyUpdate_FullMethodName            = "/rune.api.AdminService/PolicyUpdate"
	AdminService_PolicyDelete_FullMethodName            = "/rune.api.AdminService/PolicyDelete"
	AdminService_PolicyGet_FullMethodName               = "/rune.api.AdminService/PolicyGet"
	AdminService_PolicyList_FullMethodName              = "/rune.api.AdminService/PolicyList"
	AdminService_PolicyAttachToSubject_FullMethodName   = "/rune.api.AdminService/PolicyAttachToSubject"
	AdminService_PolicyDetachFromSubject_FullMethodName = "/rune.api.AdminService/PolicyDetachFromSubject"
	AdminService_UserCreate_FullMethodName              = "/rune.api.AdminService/UserCreate"
	AdminService_UserList_FullMethodName                = "/rune.api.AdminService/UserList"
	AdminService_TokenList_FullMethodName               = "/rune.api.AdminService/TokenList"
	AdminService_ListRegistries_FullMethodName          = "/rune.api.AdminService/ListRegistries"
	AdminService_GetRegistry_FullMethodName             = "/rune.api.AdminService/GetRegistry"
	AdminService_AddRegistry_FullMethodName             = "/rune.api.AdminService/AddRegistry"
	AdminService_UpdateRegistry_FullMethodName          = "/rune.api.AdminService/UpdateRegistry"
	AdminService_RemoveRegistry_FullMethodName          = "/rune.api.AdminService/RemoveRegistry"
	AdminService_BootstrapAuth_FullMethodName           = "/rune.api.AdminService/BootstrapAuth"
	AdminService_TestRegistry_FullMethodName            = "/rune.api.AdminService/TestRegistry"
	AdminService_RegistriesStatus_FullMethodName        = "/rune.api.AdminService/RegistriesStatus"
	AdminService_NetworkStatus_FullMethodName           = "/rune.api.AdminService/NetworkStatus"
)
View Source 
const (
	AuthService_WhoAmI_FullMethodName      = "/rune.api.AuthService/WhoAmI"
	AuthService_CreateToken_FullMethodName = "/rune.api.AuthService/CreateToken"
	AuthService_RevokeToken_FullMethodName = "/rune.api.AuthService/RevokeToken"
)
View Source 
const (
	ConfigmapService_CreateConfigmap_FullMethodName = "/rune.api.ConfigmapService/CreateConfigmap"
	ConfigmapService_GetConfigmap_FullMethodName    = "/rune.api.ConfigmapService/GetConfigmap"
	ConfigmapService_UpdateConfigmap_FullMethodName = "/rune.api.ConfigmapService/UpdateConfigmap"
	ConfigmapService_DeleteConfigmap_FullMethodName = "/rune.api.ConfigmapService/DeleteConfigmap"
	ConfigmapService_ListConfigmaps_FullMethodName  = "/rune.api.ConfigmapService/ListConfigmaps"
)
View Source 
const (
	HealthService_GetHealth_FullMethodName        = "/rune.api.HealthService/GetHealth"
	HealthService_GetServerVersion_FullMethodName = "/rune.api.HealthService/GetServerVersion"
)
View Source 
const (
	InstanceService_GetInstance_FullMethodName     = "/rune.api.InstanceService/GetInstance"
	InstanceService_ListInstances_FullMethodName   = "/rune.api.InstanceService/ListInstances"
	InstanceService_StartInstance_FullMethodName   = "/rune.api.InstanceService/StartInstance"
	InstanceService_StopInstance_FullMethodName    = "/rune.api.InstanceService/StopInstance"
	InstanceService_RestartInstance_FullMethodName = "/rune.api.InstanceService/RestartInstance"
	InstanceService_WatchInstances_FullMethodName  = "/rune.api.InstanceService/WatchInstances"
)
View Source 
const (
	NamespaceService_CreateNamespace_FullMethodName = "/rune.api.NamespaceService/CreateNamespace"
	NamespaceService_GetNamespace_FullMethodName    = "/rune.api.NamespaceService/GetNamespace"
	NamespaceService_ListNamespaces_FullMethodName  = "/rune.api.NamespaceService/ListNamespaces"
	NamespaceService_DeleteNamespace_FullMethodName = "/rune.api.NamespaceService/DeleteNamespace"
	NamespaceService_WatchNamespaces_FullMethodName = "/rune.api.NamespaceService/WatchNamespaces"
)
View Source 
const (
	SecretService_CreateSecret_FullMethodName        = "/rune.api.SecretService/CreateSecret"
	SecretService_GetSecret_FullMethodName           = "/rune.api.SecretService/GetSecret"
	SecretService_UpdateSecret_FullMethodName        = "/rune.api.SecretService/UpdateSecret"
	SecretService_DeleteSecret_FullMethodName        = "/rune.api.SecretService/DeleteSecret"
	SecretService_ListSecrets_FullMethodName         = "/rune.api.SecretService/ListSecrets"
	SecretService_RevealSecret_FullMethodName        = "/rune.api.SecretService/RevealSecret"
	SecretService_ListSecretVersions_FullMethodName  = "/rune.api.SecretService/ListSecretVersions"
	SecretService_RevealSecretVersion_FullMethodName = "/rune.api.SecretService/RevealSecretVersion"
	SecretService_RollbackSecret_FullMethodName      = "/rune.api.SecretService/RollbackSecret"
)
View Source 
const (
	ServiceService_CreateService_FullMethodName          = "/rune.api.ServiceService/CreateService"
	ServiceService_GetService_FullMethodName             = "/rune.api.ServiceService/GetService"
	ServiceService_ListServices_FullMethodName           = "/rune.api.ServiceService/ListServices"
	ServiceService_WatchServices_FullMethodName          = "/rune.api.ServiceService/WatchServices"
	ServiceService_UpdateService_FullMethodName          = "/rune.api.ServiceService/UpdateService"
	ServiceService_DeleteService_FullMethodName          = "/rune.api.ServiceService/DeleteService"
	ServiceService_GetDeletionStatus_FullMethodName      = "/rune.api.ServiceService/GetDeletionStatus"
	ServiceService_ListDeletionOperations_FullMethodName = "/rune.api.ServiceService/ListDeletionOperations"
	ServiceService_ScaleService_FullMethodName           = "/rune.api.ServiceService/ScaleService"
	ServiceService_WatchScaling_FullMethodName           = "/rune.api.ServiceService/WatchScaling"
	ServiceService_ListInstances_FullMethodName          = "/rune.api.ServiceService/ListInstances"
)
View Source 
const (
	StorageClassService_CreateStorageClass_FullMethodName = "/rune.api.StorageClassService/CreateStorageClass"
	StorageClassService_GetStorageClass_FullMethodName    = "/rune.api.StorageClassService/GetStorageClass"
	StorageClassService_UpdateStorageClass_FullMethodName = "/rune.api.StorageClassService/UpdateStorageClass"
	StorageClassService_DeleteStorageClass_FullMethodName = "/rune.api.StorageClassService/DeleteStorageClass"
	StorageClassService_ListStorageClasses_FullMethodName = "/rune.api.StorageClassService/ListStorageClasses"
)
View Source 
const (
	VolumeService_CreateVolume_FullMethodName         = "/rune.api.VolumeService/CreateVolume"
	VolumeService_GetVolume_FullMethodName            = "/rune.api.VolumeService/GetVolume"
	VolumeService_UpdateVolume_FullMethodName         = "/rune.api.VolumeService/UpdateVolume"
	VolumeService_DeleteVolume_FullMethodName         = "/rune.api.VolumeService/DeleteVolume"
	VolumeService_ListVolumes_FullMethodName          = "/rune.api.VolumeService/ListVolumes"
	VolumeService_RetryProvisionVolume_FullMethodName = "/rune.api.VolumeService/RetryProvisionVolume"
	VolumeService_DetachVolume_FullMethodName         = "/rune.api.VolumeService/DetachVolume"
)
View Source 
const (
	SnapshotService_CreateSnapshot_FullMethodName = "/rune.api.SnapshotService/CreateSnapshot"
	SnapshotService_GetSnapshot_FullMethodName    = "/rune.api.SnapshotService/GetSnapshot"
	SnapshotService_DeleteSnapshot_FullMethodName = "/rune.api.SnapshotService/DeleteSnapshot"
	SnapshotService_ListSnapshots_FullMethodName  = "/rune.api.SnapshotService/ListSnapshots"
	SnapshotService_RestoreVolume_FullMethodName  = "/rune.api.SnapshotService/RestoreVolume"
)
View Source 
const (
	AuditService_ListAuditEvents_FullMethodName = "/rune.api.AuditService/ListAuditEvents"
)
View Source 
const (
	ExecService_StreamExec_FullMethodName = "/rune.api.ExecService/StreamExec"
)
View Source 
const (
	LogService_StreamLogs_FullMethodName = "/rune.api.LogService/StreamLogs"
)
View Source 
const (
	WatchService_Subscribe_FullMethodName = "/rune.api.WatchService/Subscribe"
)

Variables

View Source 
var (
	ResourceType_name = map[int32]string{
		0: "RESOURCE_TYPE_UNSPECIFIED",
		1: "RESOURCE_TYPE_SERVICE",
		2: "RESOURCE_TYPE_INSTANCE",
		3: "RESOURCE_TYPE_NODE",
		4: "RESOURCE_TYPE_SECRET",
		5: "RESOURCE_TYPE_CONFIG",
	}
	ResourceType_value = map[string]int32{
		"RESOURCE_TYPE_UNSPECIFIED": 0,
		"RESOURCE_TYPE_SERVICE":     1,
		"RESOURCE_TYPE_INSTANCE":    2,
		"RESOURCE_TYPE_NODE":        3,
		"RESOURCE_TYPE_SECRET":      4,
		"RESOURCE_TYPE_CONFIG":      5,
	}
)

Enum value maps for ResourceType.

View Source 
var (
	EventType_name = map[int32]string{
		0: "EVENT_TYPE_UNSPECIFIED",
		1: "EVENT_TYPE_ADDED",
		2: "EVENT_TYPE_MODIFIED",
		3: "EVENT_TYPE_DELETED",
	}
	EventType_value = map[string]int32{
		"EVENT_TYPE_UNSPECIFIED": 0,
		"EVENT_TYPE_ADDED":       1,
		"EVENT_TYPE_MODIFIED":    2,
		"EVENT_TYPE_DELETED":     3,
	}
)

Enum value maps for EventType.

View Source 
var (
	RestartPolicy_name = map[int32]string{
		0: "RESTART_POLICY_UNSPECIFIED",
		1: "RESTART_POLICY_ALWAYS",
		2: "RESTART_POLICY_ON_FAILURE",
		3: "RESTART_POLICY_NEVER",
	}
	RestartPolicy_value = map[string]int32{
		"RESTART_POLICY_UNSPECIFIED": 0,
		"RESTART_POLICY_ALWAYS":      1,
		"RESTART_POLICY_ON_FAILURE":  2,
		"RESTART_POLICY_NEVER":       3,
	}
)

Enum value maps for RestartPolicy.

View Source 
var (
	ProbeType_name = map[int32]string{
		0: "PROBE_TYPE_UNSPECIFIED",
		1: "PROBE_TYPE_HTTP",
		2: "PROBE_TYPE_TCP",
		3: "PROBE_TYPE_COMMAND",
	}
	ProbeType_value = map[string]int32{
		"PROBE_TYPE_UNSPECIFIED": 0,
		"PROBE_TYPE_HTTP":        1,
		"PROBE_TYPE_TCP":         2,
		"PROBE_TYPE_COMMAND":     3,
	}
)

Enum value maps for ProbeType.

View Source 
var (
	HealthStatus_name = map[int32]string{
		0: "HEALTH_STATUS_UNSPECIFIED",
		1: "HEALTH_STATUS_UNKNOWN",
		2: "HEALTH_STATUS_HEALTHY",
		3: "HEALTH_STATUS_UNHEALTHY",
		4: "HEALTH_STATUS_DEGRADED",
	}
	HealthStatus_value = map[string]int32{
		"HEALTH_STATUS_UNSPECIFIED": 0,
		"HEALTH_STATUS_UNKNOWN":     1,
		"HEALTH_STATUS_HEALTHY":     2,
		"HEALTH_STATUS_UNHEALTHY":   3,
		"HEALTH_STATUS_DEGRADED":    4,
	}
)

Enum value maps for HealthStatus.

View Source 
var (
	HealthCheckType_name = map[int32]string{
		0: "HEALTH_CHECK_TYPE_UNSPECIFIED",
		1: "HEALTH_CHECK_TYPE_LIVENESS",
		2: "HEALTH_CHECK_TYPE_READINESS",
		3: "HEALTH_CHECK_TYPE_STARTUP",
	}
	HealthCheckType_value = map[string]int32{
		"HEALTH_CHECK_TYPE_UNSPECIFIED": 0,
		"HEALTH_CHECK_TYPE_LIVENESS":    1,
		"HEALTH_CHECK_TYPE_READINESS":   2,
		"HEALTH_CHECK_TYPE_STARTUP":     3,
	}
)

Enum value maps for HealthCheckType.

View Source 
var (
	InstanceStatus_name = map[int32]string{
		0: "INSTANCE_STATUS_UNSPECIFIED",
		1: "INSTANCE_STATUS_PENDING",
		2: "INSTANCE_STATUS_CREATED",
		3: "INSTANCE_STATUS_STARTING",
		4: "INSTANCE_STATUS_RUNNING",
		5: "INSTANCE_STATUS_STOPPING",
		6: "INSTANCE_STATUS_STOPPED",
		7: "INSTANCE_STATUS_FAILED",
		8: "INSTANCE_STATUS_EXITED",
		9: "INSTANCE_STATUS_DELETED",
	}
	InstanceStatus_value = map[string]int32{
		"INSTANCE_STATUS_UNSPECIFIED": 0,
		"INSTANCE_STATUS_PENDING":     1,
		"INSTANCE_STATUS_CREATED":     2,
		"INSTANCE_STATUS_STARTING":    3,
		"INSTANCE_STATUS_RUNNING":     4,
		"INSTANCE_STATUS_STOPPING":    5,
		"INSTANCE_STATUS_STOPPED":     6,
		"INSTANCE_STATUS_FAILED":      7,
		"INSTANCE_STATUS_EXITED":      8,
		"INSTANCE_STATUS_DELETED":     9,
	}
)

Enum value maps for InstanceStatus.

View Source 
var (
	ServiceStatus_name = map[int32]string{
		0: "SERVICE_STATUS_UNSPECIFIED",
		1: "SERVICE_STATUS_PENDING",
		2: "SERVICE_STATUS_RUNNING",
		3: "SERVICE_STATUS_UPDATING",
		4: "SERVICE_STATUS_FAILED",
	}
	ServiceStatus_value = map[string]int32{
		"SERVICE_STATUS_UNSPECIFIED": 0,
		"SERVICE_STATUS_PENDING":     1,
		"SERVICE_STATUS_RUNNING":     2,
		"SERVICE_STATUS_UPDATING":    3,
		"SERVICE_STATUS_FAILED":      4,
	}
)

Enum value maps for ServiceStatus.

View Source 
var (
	ScalingMode_name = map[int32]string{
		0: "SCALING_MODE_UNSPECIFIED",
		1: "SCALING_MODE_IMMEDIATE",
		2: "SCALING_MODE_GRADUAL",
	}
	ScalingMode_value = map[string]int32{
		"SCALING_MODE_UNSPECIFIED": 0,
		"SCALING_MODE_IMMEDIATE":   1,
		"SCALING_MODE_GRADUAL":     2,
	}
)

Enum value maps for ScalingMode.

View Source 
var (
	MutationKind_name = map[int32]string{
		0: "MUTATION_KIND_UNSPECIFIED",
		1: "MUTATION_KIND_PUT",
		2: "MUTATION_KIND_DELETE",
	}
	MutationKind_value = map[string]int32{
		"MUTATION_KIND_UNSPECIFIED": 0,
		"MUTATION_KIND_PUT":         1,
		"MUTATION_KIND_DELETE":      2,
	}
)

Enum value maps for MutationKind.

View Source 
var (
	WatchStatus_Code_name = map[int32]string{
		0: "CODE_UNSPECIFIED",
		1: "CODE_COMPACTED",
		2: "CODE_SLOW_CONSUMER",
		3: "CODE_SHUTTING_DOWN",
	}
	WatchStatus_Code_value = map[string]int32{
		"CODE_UNSPECIFIED":   0,
		"CODE_COMPACTED":     1,
		"CODE_SLOW_CONSUMER": 2,
		"CODE_SHUTTING_DOWN": 3,
	}
)

Enum value maps for WatchStatus_Code.

View Source 
var AdminService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.AdminService",
	HandlerType: (*AdminServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AdminBootstrap",
			Handler:    _AdminService_AdminBootstrap_Handler,
		},
		{
			MethodName: "PolicyCreate",
			Handler:    _AdminService_PolicyCreate_Handler,
		},
		{
			MethodName: "PolicyUpdate",
			Handler:    _AdminService_PolicyUpdate_Handler,
		},
		{
			MethodName: "PolicyDelete",
			Handler:    _AdminService_PolicyDelete_Handler,
		},
		{
			MethodName: "PolicyGet",
			Handler:    _AdminService_PolicyGet_Handler,
		},
		{
			MethodName: "PolicyList",
			Handler:    _AdminService_PolicyList_Handler,
		},
		{
			MethodName: "PolicyAttachToSubject",
			Handler:    _AdminService_PolicyAttachToSubject_Handler,
		},
		{
			MethodName: "PolicyDetachFromSubject",
			Handler:    _AdminService_PolicyDetachFromSubject_Handler,
		},
		{
			MethodName: "UserCreate",
			Handler:    _AdminService_UserCreate_Handler,
		},
		{
			MethodName: "UserList",
			Handler:    _AdminService_UserList_Handler,
		},
		{
			MethodName: "TokenList",
			Handler:    _AdminService_TokenList_Handler,
		},
		{
			MethodName: "ListRegistries",
			Handler:    _AdminService_ListRegistries_Handler,
		},
		{
			MethodName: "GetRegistry",
			Handler:    _AdminService_GetRegistry_Handler,
		},
		{
			MethodName: "AddRegistry",
			Handler:    _AdminService_AddRegistry_Handler,
		},
		{
			MethodName: "UpdateRegistry",
			Handler:    _AdminService_UpdateRegistry_Handler,
		},
		{
			MethodName: "RemoveRegistry",
			Handler:    _AdminService_RemoveRegistry_Handler,
		},
		{
			MethodName: "BootstrapAuth",
			Handler:    _AdminService_BootstrapAuth_Handler,
		},
		{
			MethodName: "TestRegistry",
			Handler:    _AdminService_TestRegistry_Handler,
		},
		{
			MethodName: "RegistriesStatus",
			Handler:    _AdminService_RegistriesStatus_Handler,
		},
		{
			MethodName: "NetworkStatus",
			Handler:    _AdminService_NetworkStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/admin.proto",
}

AdminService_ServiceDesc is the grpc.ServiceDesc for AdminService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var AuditService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.AuditService",
	HandlerType: (*AuditServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListAuditEvents",
			Handler:    _AuditService_ListAuditEvents_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/audit.proto",
}

AuditService_ServiceDesc is the grpc.ServiceDesc for AuditService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var AuthService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.AuthService",
	HandlerType: (*AuthServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "WhoAmI",
			Handler:    _AuthService_WhoAmI_Handler,
		},
		{
			MethodName: "CreateToken",
			Handler:    _AuthService_CreateToken_Handler,
		},
		{
			MethodName: "RevokeToken",
			Handler:    _AuthService_RevokeToken_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/auth.proto",
}

AuthService_ServiceDesc is the grpc.ServiceDesc for AuthService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ConfigmapService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.ConfigmapService",
	HandlerType: (*ConfigmapServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateConfigmap",
			Handler:    _ConfigmapService_CreateConfigmap_Handler,
		},
		{
			MethodName: "GetConfigmap",
			Handler:    _ConfigmapService_GetConfigmap_Handler,
		},
		{
			MethodName: "UpdateConfigmap",
			Handler:    _ConfigmapService_UpdateConfigmap_Handler,
		},
		{
			MethodName: "DeleteConfigmap",
			Handler:    _ConfigmapService_DeleteConfigmap_Handler,
		},
		{
			MethodName: "ListConfigmaps",
			Handler:    _ConfigmapService_ListConfigmaps_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/configmap.proto",
}

ConfigmapService_ServiceDesc is the grpc.ServiceDesc for ConfigmapService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ExecService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.ExecService",
	HandlerType: (*ExecServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamExec",
			Handler:       _ExecService_StreamExec_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "pkg/api/proto/exec.proto",
}

ExecService_ServiceDesc is the grpc.ServiceDesc for ExecService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var File_pkg_api_proto_admin_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_audit_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_auth_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_common_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_configmap_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_exec_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_health_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_instance_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_logs_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_namespace_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_secret_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_service_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_storage_proto protoreflect.FileDescriptor
View Source 
var File_pkg_api_proto_watch_proto protoreflect.FileDescriptor
View Source 
var HealthService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.HealthService",
	HandlerType: (*HealthServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetHealth",
			Handler:    _HealthService_GetHealth_Handler,
		},
		{
			MethodName: "GetServerVersion",
			Handler:    _HealthService_GetServerVersion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/health.proto",
}

HealthService_ServiceDesc is the grpc.ServiceDesc for HealthService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var InstanceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.InstanceService",
	HandlerType: (*InstanceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInstance",
			Handler:    _InstanceService_GetInstance_Handler,
		},
		{
			MethodName: "ListInstances",
			Handler:    _InstanceService_ListInstances_Handler,
		},
		{
			MethodName: "StartInstance",
			Handler:    _InstanceService_StartInstance_Handler,
		},
		{
			MethodName: "StopInstance",
			Handler:    _InstanceService_StopInstance_Handler,
		},
		{
			MethodName: "RestartInstance",
			Handler:    _InstanceService_RestartInstance_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchInstances",
			Handler:       _InstanceService_WatchInstances_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/api/proto/instance.proto",
}

InstanceService_ServiceDesc is the grpc.ServiceDesc for InstanceService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var LogService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.LogService",
	HandlerType: (*LogServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamLogs",
			Handler:       _LogService_StreamLogs_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "pkg/api/proto/logs.proto",
}

LogService_ServiceDesc is the grpc.ServiceDesc for LogService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var NamespaceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.NamespaceService",
	HandlerType: (*NamespaceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateNamespace",
			Handler:    _NamespaceService_CreateNamespace_Handler,
		},
		{
			MethodName: "GetNamespace",
			Handler:    _NamespaceService_GetNamespace_Handler,
		},
		{
			MethodName: "ListNamespaces",
			Handler:    _NamespaceService_ListNamespaces_Handler,
		},
		{
			MethodName: "DeleteNamespace",
			Handler:    _NamespaceService_DeleteNamespace_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchNamespaces",
			Handler:       _NamespaceService_WatchNamespaces_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/api/proto/namespace.proto",
}

NamespaceService_ServiceDesc is the grpc.ServiceDesc for NamespaceService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var SecretService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.SecretService",
	HandlerType: (*SecretServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSecret",
			Handler:    _SecretService_CreateSecret_Handler,
		},
		{
			MethodName: "GetSecret",
			Handler:    _SecretService_GetSecret_Handler,
		},
		{
			MethodName: "UpdateSecret",
			Handler:    _SecretService_UpdateSecret_Handler,
		},
		{
			MethodName: "DeleteSecret",
			Handler:    _SecretService_DeleteSecret_Handler,
		},
		{
			MethodName: "ListSecrets",
			Handler:    _SecretService_ListSecrets_Handler,
		},
		{
			MethodName: "RevealSecret",
			Handler:    _SecretService_RevealSecret_Handler,
		},
		{
			MethodName: "ListSecretVersions",
			Handler:    _SecretService_ListSecretVersions_Handler,
		},
		{
			MethodName: "RevealSecretVersion",
			Handler:    _SecretService_RevealSecretVersion_Handler,
		},
		{
			MethodName: "RollbackSecret",
			Handler:    _SecretService_RollbackSecret_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/secret.proto",
}

SecretService_ServiceDesc is the grpc.ServiceDesc for SecretService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ServiceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.ServiceService",
	HandlerType: (*ServiceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateService",
			Handler:    _ServiceService_CreateService_Handler,
		},
		{
			MethodName: "GetService",
			Handler:    _ServiceService_GetService_Handler,
		},
		{
			MethodName: "ListServices",
			Handler:    _ServiceService_ListServices_Handler,
		},
		{
			MethodName: "UpdateService",
			Handler:    _ServiceService_UpdateService_Handler,
		},
		{
			MethodName: "DeleteService",
			Handler:    _ServiceService_DeleteService_Handler,
		},
		{
			MethodName: "GetDeletionStatus",
			Handler:    _ServiceService_GetDeletionStatus_Handler,
		},
		{
			MethodName: "ListDeletionOperations",
			Handler:    _ServiceService_ListDeletionOperations_Handler,
		},
		{
			MethodName: "ScaleService",
			Handler:    _ServiceService_ScaleService_Handler,
		},
		{
			MethodName: "ListInstances",
			Handler:    _ServiceService_ListInstances_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchServices",
			Handler:       _ServiceService_WatchServices_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WatchScaling",
			Handler:       _ServiceService_WatchScaling_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/api/proto/service.proto",
}

ServiceService_ServiceDesc is the grpc.ServiceDesc for ServiceService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var SnapshotService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.SnapshotService",
	HandlerType: (*SnapshotServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSnapshot",
			Handler:    _SnapshotService_CreateSnapshot_Handler,
		},
		{
			MethodName: "GetSnapshot",
			Handler:    _SnapshotService_GetSnapshot_Handler,
		},
		{
			MethodName: "DeleteSnapshot",
			Handler:    _SnapshotService_DeleteSnapshot_Handler,
		},
		{
			MethodName: "ListSnapshots",
			Handler:    _SnapshotService_ListSnapshots_Handler,
		},
		{
			MethodName: "RestoreVolume",
			Handler:    _SnapshotService_RestoreVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/storage.proto",
}

SnapshotService_ServiceDesc is the grpc.ServiceDesc for SnapshotService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var StorageClassService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.StorageClassService",
	HandlerType: (*StorageClassServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateStorageClass",
			Handler:    _StorageClassService_CreateStorageClass_Handler,
		},
		{
			MethodName: "GetStorageClass",
			Handler:    _StorageClassService_GetStorageClass_Handler,
		},
		{
			MethodName: "UpdateStorageClass",
			Handler:    _StorageClassService_UpdateStorageClass_Handler,
		},
		{
			MethodName: "DeleteStorageClass",
			Handler:    _StorageClassService_DeleteStorageClass_Handler,
		},
		{
			MethodName: "ListStorageClasses",
			Handler:    _StorageClassService_ListStorageClasses_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/storage.proto",
}

StorageClassService_ServiceDesc is the grpc.ServiceDesc for StorageClassService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var VolumeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.VolumeService",
	HandlerType: (*VolumeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateVolume",
			Handler:    _VolumeService_CreateVolume_Handler,
		},
		{
			MethodName: "GetVolume",
			Handler:    _VolumeService_GetVolume_Handler,
		},
		{
			MethodName: "UpdateVolume",
			Handler:    _VolumeService_UpdateVolume_Handler,
		},
		{
			MethodName: "DeleteVolume",
			Handler:    _VolumeService_DeleteVolume_Handler,
		},
		{
			MethodName: "ListVolumes",
			Handler:    _VolumeService_ListVolumes_Handler,
		},
		{
			MethodName: "RetryProvisionVolume",
			Handler:    _VolumeService_RetryProvisionVolume_Handler,
		},
		{
			MethodName: "DetachVolume",
			Handler:    _VolumeService_DetachVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/proto/storage.proto",
}

VolumeService_ServiceDesc is the grpc.ServiceDesc for VolumeService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var WatchService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rune.api.WatchService",
	HandlerType: (*WatchServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _WatchService_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pkg/api/proto/watch.proto",
}

WatchService_ServiceDesc is the grpc.ServiceDesc for WatchService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterAdminServiceHandler 

func RegisterAdminServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAdminServiceHandler registers the http handlers for service AdminService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAdminServiceHandlerClient 

func RegisterAdminServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AdminServiceClient) error

RegisterAdminServiceHandlerClient registers the http handlers for service AdminService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AdminServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AdminServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AdminServiceClient" to call the correct interceptors.

func RegisterAdminServiceHandlerFromEndpoint 

func RegisterAdminServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAdminServiceHandlerFromEndpoint is same as RegisterAdminServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAdminServiceHandlerServer 

func RegisterAdminServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AdminServiceServer) error

RegisterAdminServiceHandlerServer registers the http handlers for service AdminService to "mux". UnaryRPC :call AdminServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAdminServiceHandlerFromEndpoint instead.

func RegisterAdminServiceServer 

func RegisterAdminServiceServer(s grpc.ServiceRegistrar, srv AdminServiceServer)

func RegisterAuditServiceHandler 

func RegisterAuditServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAuditServiceHandler registers the http handlers for service AuditService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAuditServiceHandlerClient 

func RegisterAuditServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AuditServiceClient) error

RegisterAuditServiceHandlerClient registers the http handlers for service AuditService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AuditServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuditServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AuditServiceClient" to call the correct interceptors.

func RegisterAuditServiceHandlerFromEndpoint 

func RegisterAuditServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAuditServiceHandlerFromEndpoint is same as RegisterAuditServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAuditServiceHandlerServer 

func RegisterAuditServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AuditServiceServer) error

RegisterAuditServiceHandlerServer registers the http handlers for service AuditService to "mux". UnaryRPC :call AuditServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAuditServiceHandlerFromEndpoint instead.

func RegisterAuditServiceServer 

func RegisterAuditServiceServer(s grpc.ServiceRegistrar, srv AuditServiceServer)

func RegisterAuthServiceHandler 

func RegisterAuthServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAuthServiceHandler registers the http handlers for service AuthService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAuthServiceHandlerClient 

func RegisterAuthServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AuthServiceClient) error

RegisterAuthServiceHandlerClient registers the http handlers for service AuthService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AuthServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AuthServiceClient" to call the correct interceptors.

func RegisterAuthServiceHandlerFromEndpoint 

func RegisterAuthServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAuthServiceHandlerFromEndpoint is same as RegisterAuthServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAuthServiceHandlerServer 

func RegisterAuthServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AuthServiceServer) error

RegisterAuthServiceHandlerServer registers the http handlers for service AuthService to "mux". UnaryRPC :call AuthServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAuthServiceHandlerFromEndpoint instead.

func RegisterAuthServiceServer 

func RegisterAuthServiceServer(s grpc.ServiceRegistrar, srv AuthServiceServer)

func RegisterConfigmapServiceHandler 

func RegisterConfigmapServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterConfigmapServiceHandler registers the http handlers for service ConfigmapService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterConfigmapServiceHandlerClient 

func RegisterConfigmapServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ConfigmapServiceClient) error

RegisterConfigmapServiceHandlerClient registers the http handlers for service ConfigmapService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ConfigmapServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ConfigmapServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ConfigmapServiceClient" to call the correct interceptors.

func RegisterConfigmapServiceHandlerFromEndpoint 

func RegisterConfigmapServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterConfigmapServiceHandlerFromEndpoint is same as RegisterConfigmapServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterConfigmapServiceHandlerServer 

func RegisterConfigmapServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ConfigmapServiceServer) error

RegisterConfigmapServiceHandlerServer registers the http handlers for service ConfigmapService to "mux". UnaryRPC :call ConfigmapServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterConfigmapServiceHandlerFromEndpoint instead.

func RegisterConfigmapServiceServer 

func RegisterConfigmapServiceServer(s grpc.ServiceRegistrar, srv ConfigmapServiceServer)

func RegisterExecServiceHandler 

func RegisterExecServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterExecServiceHandler registers the http handlers for service ExecService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterExecServiceHandlerClient 

func RegisterExecServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ExecServiceClient) error

RegisterExecServiceHandlerClient registers the http handlers for service ExecService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ExecServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ExecServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ExecServiceClient" to call the correct interceptors.

func RegisterExecServiceHandlerFromEndpoint 

func RegisterExecServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterExecServiceHandlerFromEndpoint is same as RegisterExecServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterExecServiceHandlerServer 

func RegisterExecServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ExecServiceServer) error

RegisterExecServiceHandlerServer registers the http handlers for service ExecService to "mux". UnaryRPC :call ExecServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterExecServiceHandlerFromEndpoint instead.

func RegisterExecServiceServer 

func RegisterExecServiceServer(s grpc.ServiceRegistrar, srv ExecServiceServer)

func RegisterHealthServiceHandler 

func RegisterHealthServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterHealthServiceHandler registers the http handlers for service HealthService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterHealthServiceHandlerClient 

func RegisterHealthServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client HealthServiceClient) error

RegisterHealthServiceHandlerClient registers the http handlers for service HealthService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "HealthServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "HealthServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "HealthServiceClient" to call the correct interceptors.

func RegisterHealthServiceHandlerFromEndpoint 

func RegisterHealthServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterHealthServiceHandlerFromEndpoint is same as RegisterHealthServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterHealthServiceHandlerServer 

func RegisterHealthServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server HealthServiceServer) error

RegisterHealthServiceHandlerServer registers the http handlers for service HealthService to "mux". UnaryRPC :call HealthServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterHealthServiceHandlerFromEndpoint instead.

func RegisterHealthServiceServer 

func RegisterHealthServiceServer(s grpc.ServiceRegistrar, srv HealthServiceServer)

func RegisterInstanceServiceHandler 

func RegisterInstanceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterInstanceServiceHandler registers the http handlers for service InstanceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterInstanceServiceHandlerClient 

func RegisterInstanceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client InstanceServiceClient) error

RegisterInstanceServiceHandlerClient registers the http handlers for service InstanceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "InstanceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "InstanceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "InstanceServiceClient" to call the correct interceptors.

func RegisterInstanceServiceHandlerFromEndpoint 

func RegisterInstanceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterInstanceServiceHandlerFromEndpoint is same as RegisterInstanceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterInstanceServiceHandlerServer 

func RegisterInstanceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server InstanceServiceServer) error

RegisterInstanceServiceHandlerServer registers the http handlers for service InstanceService to "mux". UnaryRPC :call InstanceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterInstanceServiceHandlerFromEndpoint instead.

func RegisterInstanceServiceServer 

func RegisterInstanceServiceServer(s grpc.ServiceRegistrar, srv InstanceServiceServer)

func RegisterLogServiceHandler 

func RegisterLogServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLogServiceHandler registers the http handlers for service LogService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLogServiceHandlerClient 

func RegisterLogServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LogServiceClient) error

RegisterLogServiceHandlerClient registers the http handlers for service LogService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LogServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LogServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LogServiceClient" to call the correct interceptors.

func RegisterLogServiceHandlerFromEndpoint 

func RegisterLogServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLogServiceHandlerFromEndpoint is same as RegisterLogServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLogServiceHandlerServer 

func RegisterLogServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LogServiceServer) error

RegisterLogServiceHandlerServer registers the http handlers for service LogService to "mux". UnaryRPC :call LogServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterLogServiceHandlerFromEndpoint instead.

func RegisterLogServiceServer 

func RegisterLogServiceServer(s grpc.ServiceRegistrar, srv LogServiceServer)

func RegisterNamespaceServiceHandler 

func RegisterNamespaceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNamespaceServiceHandler registers the http handlers for service NamespaceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNamespaceServiceHandlerClient 

func RegisterNamespaceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NamespaceServiceClient) error

RegisterNamespaceServiceHandlerClient registers the http handlers for service NamespaceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NamespaceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NamespaceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NamespaceServiceClient" to call the correct interceptors.

func RegisterNamespaceServiceHandlerFromEndpoint 

func RegisterNamespaceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNamespaceServiceHandlerFromEndpoint is same as RegisterNamespaceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNamespaceServiceHandlerServer 

func RegisterNamespaceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NamespaceServiceServer) error

RegisterNamespaceServiceHandlerServer registers the http handlers for service NamespaceService to "mux". UnaryRPC :call NamespaceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNamespaceServiceHandlerFromEndpoint instead.

func RegisterNamespaceServiceServer 

func RegisterNamespaceServiceServer(s grpc.ServiceRegistrar, srv NamespaceServiceServer)

func RegisterSecretServiceHandler 

func RegisterSecretServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSecretServiceHandler registers the http handlers for service SecretService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSecretServiceHandlerClient 

func RegisterSecretServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SecretServiceClient) error

RegisterSecretServiceHandlerClient registers the http handlers for service SecretService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SecretServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SecretServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SecretServiceClient" to call the correct interceptors.

func RegisterSecretServiceHandlerFromEndpoint 

func RegisterSecretServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSecretServiceHandlerFromEndpoint is same as RegisterSecretServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSecretServiceHandlerServer 

func RegisterSecretServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SecretServiceServer) error

RegisterSecretServiceHandlerServer registers the http handlers for service SecretService to "mux". UnaryRPC :call SecretServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSecretServiceHandlerFromEndpoint instead.

func RegisterSecretServiceServer 

func RegisterSecretServiceServer(s grpc.ServiceRegistrar, srv SecretServiceServer)

func RegisterServiceServiceHandler 

func RegisterServiceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceServiceHandler registers the http handlers for service ServiceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceServiceHandlerClient 

func RegisterServiceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceServiceClient) error

RegisterServiceServiceHandlerClient registers the http handlers for service ServiceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceServiceClient" to call the correct interceptors.

func RegisterServiceServiceHandlerFromEndpoint 

func RegisterServiceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceServiceHandlerFromEndpoint is same as RegisterServiceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceServiceHandlerServer 

func RegisterServiceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceServiceServer) error

RegisterServiceServiceHandlerServer registers the http handlers for service ServiceService to "mux". UnaryRPC :call ServiceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceServiceHandlerFromEndpoint instead.

func RegisterServiceServiceServer 

func RegisterServiceServiceServer(s grpc.ServiceRegistrar, srv ServiceServiceServer)

func RegisterSnapshotServiceHandler 

func RegisterSnapshotServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSnapshotServiceHandler registers the http handlers for service SnapshotService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSnapshotServiceHandlerClient 

func RegisterSnapshotServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SnapshotServiceClient) error

RegisterSnapshotServiceHandlerClient registers the http handlers for service SnapshotService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SnapshotServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SnapshotServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SnapshotServiceClient" to call the correct interceptors.

func RegisterSnapshotServiceHandlerFromEndpoint 

func RegisterSnapshotServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSnapshotServiceHandlerFromEndpoint is same as RegisterSnapshotServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSnapshotServiceHandlerServer 

func RegisterSnapshotServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SnapshotServiceServer) error

RegisterSnapshotServiceHandlerServer registers the http handlers for service SnapshotService to "mux". UnaryRPC :call SnapshotServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSnapshotServiceHandlerFromEndpoint instead.

func RegisterSnapshotServiceServer 

func RegisterSnapshotServiceServer(s grpc.ServiceRegistrar, srv SnapshotServiceServer)

func RegisterStorageClassServiceHandler 

func RegisterStorageClassServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterStorageClassServiceHandler registers the http handlers for service StorageClassService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterStorageClassServiceHandlerClient 

func RegisterStorageClassServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StorageClassServiceClient) error

RegisterStorageClassServiceHandlerClient registers the http handlers for service StorageClassService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StorageClassServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StorageClassServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "StorageClassServiceClient" to call the correct interceptors.

func RegisterStorageClassServiceHandlerFromEndpoint 

func RegisterStorageClassServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterStorageClassServiceHandlerFromEndpoint is same as RegisterStorageClassServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterStorageClassServiceHandlerServer 

func RegisterStorageClassServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StorageClassServiceServer) error

RegisterStorageClassServiceHandlerServer registers the http handlers for service StorageClassService to "mux". UnaryRPC :call StorageClassServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterStorageClassServiceHandlerFromEndpoint instead.

func RegisterStorageClassServiceServer 

func RegisterStorageClassServiceServer(s grpc.ServiceRegistrar, srv StorageClassServiceServer)

func RegisterVolumeServiceHandler 

func RegisterVolumeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterVolumeServiceHandler registers the http handlers for service VolumeService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterVolumeServiceHandlerClient 

func RegisterVolumeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client VolumeServiceClient) error

RegisterVolumeServiceHandlerClient registers the http handlers for service VolumeService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "VolumeServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "VolumeServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "VolumeServiceClient" to call the correct interceptors.

func RegisterVolumeServiceHandlerFromEndpoint 

func RegisterVolumeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterVolumeServiceHandlerFromEndpoint is same as RegisterVolumeServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterVolumeServiceHandlerServer 

func RegisterVolumeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server VolumeServiceServer) error

RegisterVolumeServiceHandlerServer registers the http handlers for service VolumeService to "mux". UnaryRPC :call VolumeServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterVolumeServiceHandlerFromEndpoint instead.

func RegisterVolumeServiceServer 

func RegisterVolumeServiceServer(s grpc.ServiceRegistrar, srv VolumeServiceServer)

func RegisterWatchServiceHandler 

func RegisterWatchServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterWatchServiceHandler registers the http handlers for service WatchService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterWatchServiceHandlerClient 

func RegisterWatchServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client WatchServiceClient) error

RegisterWatchServiceHandlerClient registers the http handlers for service WatchService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "WatchServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WatchServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "WatchServiceClient" to call the correct interceptors.

func RegisterWatchServiceHandlerFromEndpoint 

func RegisterWatchServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterWatchServiceHandlerFromEndpoint is same as RegisterWatchServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterWatchServiceHandlerServer 

func RegisterWatchServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server WatchServiceServer) error

RegisterWatchServiceHandlerServer registers the http handlers for service WatchService to "mux". UnaryRPC :call WatchServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterWatchServiceHandlerFromEndpoint instead.

func RegisterWatchServiceServer 

func RegisterWatchServiceServer(s grpc.ServiceRegistrar, srv WatchServiceServer)

Types

type AddRegistryRequest 

type AddRegistryRequest struct {
	Registry *RegistryConfig `protobuf:"bytes,1,opt,name=registry,proto3" json:"registry,omitempty"`
	// contains filtered or unexported fields
}

func (*AddRegistryRequest) Descriptor deprecated 

func (*AddRegistryRequest) Descriptor() ([]byte, []int)

Deprecated: Use AddRegistryRequest.ProtoReflect.Descriptor instead.

func (*AddRegistryRequest) GetRegistry 

func (x *AddRegistryRequest) GetRegistry() *RegistryConfig

func (*AddRegistryRequest) ProtoMessage 

func (*AddRegistryRequest) ProtoMessage()

func (*AddRegistryRequest) ProtoReflect 

func (x *AddRegistryRequest) ProtoReflect() protoreflect.Message

func (*AddRegistryRequest) Reset 

func (x *AddRegistryRequest) Reset()

func (*AddRegistryRequest) String 

func (x *AddRegistryRequest) String() string

type AddRegistryResponse 

type AddRegistryResponse struct {
	Registry *RegistryConfig `protobuf:"bytes,1,opt,name=registry,proto3" json:"registry,omitempty"`
	// contains filtered or unexported fields
}

func (*AddRegistryResponse) Descriptor deprecated 

func (*AddRegistryResponse) Descriptor() ([]byte, []int)

Deprecated: Use AddRegistryResponse.ProtoReflect.Descriptor instead.

func (*AddRegistryResponse) GetRegistry 

func (x *AddRegistryResponse) GetRegistry() *RegistryConfig

func (*AddRegistryResponse) ProtoMessage 

func (*AddRegistryResponse) ProtoMessage()

func (*AddRegistryResponse) ProtoReflect 

func (x *AddRegistryResponse) ProtoReflect() protoreflect.Message

func (*AddRegistryResponse) Reset 

func (x *AddRegistryResponse) Reset()

func (*AddRegistryResponse) String 

func (x *AddRegistryResponse) String() string

type AdminBootstrapRequest 

type AdminBootstrapRequest struct {
	// contains filtered or unexported fields
}

func (*AdminBootstrapRequest) Descriptor deprecated 

func (*AdminBootstrapRequest) Descriptor() ([]byte, []int)

Deprecated: Use AdminBootstrapRequest.ProtoReflect.Descriptor instead.

func (*AdminBootstrapRequest) ProtoMessage 

func (*AdminBootstrapRequest) ProtoMessage()

func (*AdminBootstrapRequest) ProtoReflect 

func (x *AdminBootstrapRequest) ProtoReflect() protoreflect.Message

func (*AdminBootstrapRequest) Reset 

func (x *AdminBootstrapRequest) Reset()

func (*AdminBootstrapRequest) String 

func (x *AdminBootstrapRequest) String() string

type AdminBootstrapResponse 

type AdminBootstrapResponse struct {
	TokenId     string `protobuf:"bytes,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
	TokenSecret string `protobuf:"bytes,2,opt,name=token_secret,json=tokenSecret,proto3" json:"token_secret,omitempty"` // returned once
	SubjectId   string `protobuf:"bytes,3,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`       // root/admin subject id
	// contains filtered or unexported fields
}

func (*AdminBootstrapResponse) Descriptor deprecated 

func (*AdminBootstrapResponse) Descriptor() ([]byte, []int)

Deprecated: Use AdminBootstrapResponse.ProtoReflect.Descriptor instead.

func (*AdminBootstrapResponse) GetSubjectId 

func (x *AdminBootstrapResponse) GetSubjectId() string

func (*AdminBootstrapResponse) GetTokenId 

func (x *AdminBootstrapResponse) GetTokenId() string

func (*AdminBootstrapResponse) GetTokenSecret 

func (x *AdminBootstrapResponse) GetTokenSecret() string

func (*AdminBootstrapResponse) ProtoMessage 

func (*AdminBootstrapResponse) ProtoMessage()

func (*AdminBootstrapResponse) ProtoReflect 

func (x *AdminBootstrapResponse) ProtoReflect() protoreflect.Message

func (*AdminBootstrapResponse) Reset 

func (x *AdminBootstrapResponse) Reset()

func (*AdminBootstrapResponse) String 

func (x *AdminBootstrapResponse) String() string

type AdminServiceClient 

type AdminServiceClient interface {
	AdminBootstrap(ctx context.Context, in *AdminBootstrapRequest, opts ...grpc.CallOption) (*AdminBootstrapResponse, error)
	PolicyCreate(ctx context.Context, in *PolicyCreateRequest, opts ...grpc.CallOption) (*PolicyCreateResponse, error)
	PolicyUpdate(ctx context.Context, in *PolicyUpdateRequest, opts ...grpc.CallOption) (*PolicyUpdateResponse, error)
	PolicyDelete(ctx context.Context, in *PolicyDeleteRequest, opts ...grpc.CallOption) (*PolicyDeleteResponse, error)
	PolicyGet(ctx context.Context, in *PolicyGetRequest, opts ...grpc.CallOption) (*PolicyGetResponse, error)
	PolicyList(ctx context.Context, in *PolicyListRequest, opts ...grpc.CallOption) (*PolicyListResponse, error)
	PolicyAttachToSubject(ctx context.Context, in *PolicyAttachToSubjectRequest, opts ...grpc.CallOption) (*PolicyAttachToSubjectResponse, error)
	PolicyDetachFromSubject(ctx context.Context, in *PolicyDetachFromSubjectRequest, opts ...grpc.CallOption) (*PolicyDetachFromSubjectResponse, error)
	UserCreate(ctx context.Context, in *UserCreateRequest, opts ...grpc.CallOption) (*UserCreateResponse, error)
	UserList(ctx context.Context, in *UserListRequest, opts ...grpc.CallOption) (*UserListResponse, error)
	// List tokens (no secrets)
	TokenList(ctx context.Context, in *TokenListRequest, opts ...grpc.CallOption) (*TokenListResponse, error)
	// Registry admin RPCs
	ListRegistries(ctx context.Context, in *ListRegistriesRequest, opts ...grpc.CallOption) (*ListRegistriesResponse, error)
	GetRegistry(ctx context.Context, in *GetRegistryRequest, opts ...grpc.CallOption) (*GetRegistryResponse, error)
	AddRegistry(ctx context.Context, in *AddRegistryRequest, opts ...grpc.CallOption) (*AddRegistryResponse, error)
	UpdateRegistry(ctx context.Context, in *UpdateRegistryRequest, opts ...grpc.CallOption) (*UpdateRegistryResponse, error)
	RemoveRegistry(ctx context.Context, in *RemoveRegistryRequest, opts ...grpc.CallOption) (*RemoveRegistryResponse, error)
	BootstrapAuth(ctx context.Context, in *BootstrapAuthRequest, opts ...grpc.CallOption) (*BootstrapAuthResponse, error)
	TestRegistry(ctx context.Context, in *TestRegistryRequest, opts ...grpc.CallOption) (*TestRegistryResponse, error)
	RegistriesStatus(ctx context.Context, in *RegistriesStatusRequest, opts ...grpc.CallOption) (*RegistriesStatusResponse, error)
	// Network status: inspect ClusterNetwork CIDR + VIP allocations.
	NetworkStatus(ctx context.Context, in *NetworkStatusRequest, opts ...grpc.CallOption) (*NetworkStatusResponse, error)
}

AdminServiceClient is the client API for AdminService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewAdminServiceClient 

func NewAdminServiceClient(cc grpc.ClientConnInterface) AdminServiceClient

type AdminServiceServer 

type AdminServiceServer interface {
	AdminBootstrap(context.Context, *AdminBootstrapRequest) (*AdminBootstrapResponse, error)
	PolicyCreate(context.Context, *PolicyCreateRequest) (*PolicyCreateResponse, error)
	PolicyUpdate(context.Context, *PolicyUpdateRequest) (*PolicyUpdateResponse, error)
	PolicyDelete(context.Context, *PolicyDeleteRequest) (*PolicyDeleteResponse, error)
	PolicyGet(context.Context, *PolicyGetRequest) (*PolicyGetResponse, error)
	PolicyList(context.Context, *PolicyListRequest) (*PolicyListResponse, error)
	PolicyAttachToSubject(context.Context, *PolicyAttachToSubjectRequest) (*PolicyAttachToSubjectResponse, error)
	PolicyDetachFromSubject(context.Context, *PolicyDetachFromSubjectRequest) (*PolicyDetachFromSubjectResponse, error)
	UserCreate(context.Context, *UserCreateRequest) (*UserCreateResponse, error)
	UserList(context.Context, *UserListRequest) (*UserListResponse, error)
	// List tokens (no secrets)
	TokenList(context.Context, *TokenListRequest) (*TokenListResponse, error)
	// Registry admin RPCs
	ListRegistries(context.Context, *ListRegistriesRequest) (*ListRegistriesResponse, error)
	GetRegistry(context.Context, *GetRegistryRequest) (*GetRegistryResponse, error)
	AddRegistry(context.Context, *AddRegistryRequest) (*AddRegistryResponse, error)
	UpdateRegistry(context.Context, *UpdateRegistryRequest) (*UpdateRegistryResponse, error)
	RemoveRegistry(context.Context, *RemoveRegistryRequest) (*RemoveRegistryResponse, error)
	BootstrapAuth(context.Context, *BootstrapAuthRequest) (*BootstrapAuthResponse, error)
	TestRegistry(context.Context, *TestRegistryRequest) (*TestRegistryResponse, error)
	RegistriesStatus(context.Context, *RegistriesStatusRequest) (*RegistriesStatusResponse, error)
	// Network status: inspect ClusterNetwork CIDR + VIP allocations.
	NetworkStatus(context.Context, *NetworkStatusRequest) (*NetworkStatusResponse, error)
	// contains filtered or unexported methods
}

AdminServiceServer is the server API for AdminService service. All implementations must embed UnimplementedAdminServiceServer for forward compatibility.

type AuditEvent 

type AuditEvent struct {
	Id          string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Timestamp   string            `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // RFC3339Nano UTC
	Actor       string            `protobuf:"bytes,3,opt,name=actor,proto3" json:"actor,omitempty"`
	Action      string            `protobuf:"bytes,4,opt,name=action,proto3" json:"action,omitempty"`
	Resource    string            `protobuf:"bytes,5,opt,name=resource,proto3" json:"resource,omitempty"`
	ResourceRef string            `protobuf:"bytes,6,opt,name=resource_ref,json=resourceRef,proto3" json:"resource_ref,omitempty"`
	Namespace   string            `protobuf:"bytes,7,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Outcome     string            `protobuf:"bytes,8,opt,name=outcome,proto3" json:"outcome,omitempty"` // success | denied | error
	Message     string            `protobuf:"bytes,9,opt,name=message,proto3" json:"message,omitempty"`
	Metadata    map[string]string `` /* 144-byte string literal not displayed */
	// contains filtered or unexported fields
}

AuditEvent records a single security-relevant operation. See pkg/types/audit.go for field semantics.

func (*AuditEvent) Descriptor deprecated 

func (*AuditEvent) Descriptor() ([]byte, []int)

Deprecated: Use AuditEvent.ProtoReflect.Descriptor instead.

func (*AuditEvent) GetAction 

func (x *AuditEvent) GetAction() string

func (*AuditEvent) GetActor 

func (x *AuditEvent) GetActor() string

func (*AuditEvent) GetId 

func (x *AuditEvent) GetId() string

func (*AuditEvent) GetMessage 

func (x *AuditEvent) GetMessage() string

func (*AuditEvent) GetMetadata 

func (x *AuditEvent) GetMetadata() map[string]string

func (*AuditEvent) GetNamespace 

func (x *AuditEvent) GetNamespace() string

func (*AuditEvent) GetOutcome 

func (x *AuditEvent) GetOutcome() string

func (*AuditEvent) GetResource 

func (x *AuditEvent) GetResource() string

func (*AuditEvent) GetResourceRef 

func (x *AuditEvent) GetResourceRef() string

func (*AuditEvent) GetTimestamp 

func (x *AuditEvent) GetTimestamp() string

func (*AuditEvent) ProtoMessage 

func (*AuditEvent) ProtoMessage()

func (*AuditEvent) ProtoReflect 

func (x *AuditEvent) ProtoReflect() protoreflect.Message

func (*AuditEvent) Reset 

func (x *AuditEvent) Reset()

func (*AuditEvent) String 

func (x *AuditEvent) String() string

type AuditServiceClient 

type AuditServiceClient interface {
	// ListAuditEvents returns audit events matching the filter, newest first.
	ListAuditEvents(ctx context.Context, in *ListAuditEventsRequest, opts ...grpc.CallOption) (*ListAuditEventsResponse, error)
}

AuditServiceClient is the client API for AuditService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewAuditServiceClient 

func NewAuditServiceClient(cc grpc.ClientConnInterface) AuditServiceClient

type AuditServiceServer 

type AuditServiceServer interface {
	// ListAuditEvents returns audit events matching the filter, newest first.
	ListAuditEvents(context.Context, *ListAuditEventsRequest) (*ListAuditEventsResponse, error)
	// contains filtered or unexported methods
}

AuditServiceServer is the server API for AuditService service. All implementations must embed UnimplementedAuditServiceServer for forward compatibility.

type AuthServiceClient 

type AuthServiceClient interface {
	WhoAmI(ctx context.Context, in *WhoAmIRequest, opts ...grpc.CallOption) (*WhoAmIResponse, error)
	CreateToken(ctx context.Context, in *CreateTokenRequest, opts ...grpc.CallOption) (*CreateTokenResponse, error)
	RevokeToken(ctx context.Context, in *RevokeTokenRequest, opts ...grpc.CallOption) (*RevokeTokenResponse, error)
}

AuthServiceClient is the client API for AuthService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewAuthServiceClient 

func NewAuthServiceClient(cc grpc.ClientConnInterface) AuthServiceClient

type AuthServiceServer 

type AuthServiceServer interface {
	WhoAmI(context.Context, *WhoAmIRequest) (*WhoAmIResponse, error)
	CreateToken(context.Context, *CreateTokenRequest) (*CreateTokenResponse, error)
	RevokeToken(context.Context, *RevokeTokenRequest) (*RevokeTokenResponse, error)
	// contains filtered or unexported methods
}

AuthServiceServer is the server API for AuthService service. All implementations must embed UnimplementedAuthServiceServer for forward compatibility.

type BootstrapAuthRequest 

type BootstrapAuthRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // bootstrap a specific registry by name
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` // bootstrap all registries of this type (e.g., ecr, ghcr)
	All  bool   `protobuf:"varint,3,opt,name=all,proto3" json:"all,omitempty"`  // bootstrap all registries
	// contains filtered or unexported fields
}

func (*BootstrapAuthRequest) Descriptor deprecated 

func (*BootstrapAuthRequest) Descriptor() ([]byte, []int)

Deprecated: Use BootstrapAuthRequest.ProtoReflect.Descriptor instead.

func (*BootstrapAuthRequest) GetAll 

func (x *BootstrapAuthRequest) GetAll() bool

func (*BootstrapAuthRequest) GetName 

func (x *BootstrapAuthRequest) GetName() string

func (*BootstrapAuthRequest) GetType 

func (x *BootstrapAuthRequest) GetType() string

func (*BootstrapAuthRequest) ProtoMessage 

func (*BootstrapAuthRequest) ProtoMessage()

func (*BootstrapAuthRequest) ProtoReflect 

func (x *BootstrapAuthRequest) ProtoReflect() protoreflect.Message

func (*BootstrapAuthRequest) Reset 

func (x *BootstrapAuthRequest) Reset()

func (*BootstrapAuthRequest) String 

func (x *BootstrapAuthRequest) String() string

type BootstrapAuthResponse 

type BootstrapAuthResponse struct {
	Updated int32 `protobuf:"varint,1,opt,name=updated,proto3" json:"updated,omitempty"`
	// contains filtered or unexported fields
}

func (*BootstrapAuthResponse) Descriptor deprecated 

func (*BootstrapAuthResponse) Descriptor() ([]byte, []int)

Deprecated: Use BootstrapAuthResponse.ProtoReflect.Descriptor instead.

func (*BootstrapAuthResponse) GetUpdated 

func (x *BootstrapAuthResponse) GetUpdated() int32

func (*BootstrapAuthResponse) ProtoMessage 

func (*BootstrapAuthResponse) ProtoMessage()

func (*BootstrapAuthResponse) ProtoReflect 

func (x *BootstrapAuthResponse) ProtoReflect() protoreflect.Message

func (*BootstrapAuthResponse) Reset 

func (x *BootstrapAuthResponse) Reset()

func (*BootstrapAuthResponse) String 

func (x *BootstrapAuthResponse) String() string

type ComponentHealth 

type ComponentHealth struct {

	// Component type (e.g., "service", "instance", "node", "api-server")
	ComponentType string `protobuf:"bytes,1,opt,name=component_type,json=componentType,proto3" json:"component_type,omitempty"`
	// Component identifier
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the component
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace of the component (if applicable)
	Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Overall health status
	Status HealthStatus `protobuf:"varint,5,opt,name=status,proto3,enum=rune.api.HealthStatus" json:"status,omitempty"`
	// Detailed message about the health status
	Message string `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
	// Last update timestamp (RFC 3339 format)
	Timestamp string `protobuf:"bytes,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Individual health check results
	CheckResults []*HealthCheckResult `protobuf:"bytes,8,rep,name=check_results,json=checkResults,proto3" json:"check_results,omitempty"`
	// contains filtered or unexported fields
}

ComponentHealth represents the health status of a component.

func (*ComponentHealth) Descriptor deprecated 

func (*ComponentHealth) Descriptor() ([]byte, []int)

Deprecated: Use ComponentHealth.ProtoReflect.Descriptor instead.

func (*ComponentHealth) GetCheckResults 

func (x *ComponentHealth) GetCheckResults() []*HealthCheckResult

func (*ComponentHealth) GetComponentType 

func (x *ComponentHealth) GetComponentType() string

func (*ComponentHealth) GetId 

func (x *ComponentHealth) GetId() string

func (*ComponentHealth) GetMessage 

func (x *ComponentHealth) GetMessage() string

func (*ComponentHealth) GetName 

func (x *ComponentHealth) GetName() string

func (*ComponentHealth) GetNamespace 

func (x *ComponentHealth) GetNamespace() string

func (*ComponentHealth) GetStatus 

func (x *ComponentHealth) GetStatus() HealthStatus

func (*ComponentHealth) GetTimestamp 

func (x *ComponentHealth) GetTimestamp() string

func (*ComponentHealth) ProtoMessage 

func (*ComponentHealth) ProtoMessage()

func (*ComponentHealth) ProtoReflect 

func (x *ComponentHealth) ProtoReflect() protoreflect.Message

func (*ComponentHealth) Reset 

func (x *ComponentHealth) Reset()

func (*ComponentHealth) String 

func (x *ComponentHealth) String() string

type Configmap 

type Configmap struct {
	Name      string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string            `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Data      map[string]string `` /* 135-byte string literal not displayed */
	Version   int32             `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	CreatedAt string            `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt string            `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

func (*Configmap) Descriptor deprecated 

func (*Configmap) Descriptor() ([]byte, []int)

Deprecated: Use Configmap.ProtoReflect.Descriptor instead.

func (*Configmap) GetCreatedAt 

func (x *Configmap) GetCreatedAt() string

func (*Configmap) GetData 

func (x *Configmap) GetData() map[string]string

func (*Configmap) GetName 

func (x *Configmap) GetName() string

func (*Configmap) GetNamespace 

func (x *Configmap) GetNamespace() string

func (*Configmap) GetUpdatedAt 

func (x *Configmap) GetUpdatedAt() string

func (*Configmap) GetVersion 

func (x *Configmap) GetVersion() int32

func (*Configmap) ProtoMessage 

func (*Configmap) ProtoMessage()

func (*Configmap) ProtoReflect 

func (x *Configmap) ProtoReflect() protoreflect.Message

func (*Configmap) Reset 

func (x *Configmap) Reset()

func (*Configmap) String 

func (x *Configmap) String() string

type ConfigmapMount 

type ConfigmapMount struct {
	Name          string       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	MountPath     string       `protobuf:"bytes,2,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	ConfigmapName string       `protobuf:"bytes,3,opt,name=configmap_name,json=configmapName,proto3" json:"configmap_name,omitempty"`
	Items         []*KeyToPath `protobuf:"bytes,4,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

ConfigmapMount defines a config to be mounted in a container.

func (*ConfigmapMount) Descriptor deprecated 

func (*ConfigmapMount) Descriptor() ([]byte, []int)

Deprecated: Use ConfigmapMount.ProtoReflect.Descriptor instead.

func (*ConfigmapMount) GetConfigmapName 

func (x *ConfigmapMount) GetConfigmapName() string

func (*ConfigmapMount) GetItems 

func (x *ConfigmapMount) GetItems() []*KeyToPath

func (*ConfigmapMount) GetMountPath 

func (x *ConfigmapMount) GetMountPath() string

func (*ConfigmapMount) GetName 

func (x *ConfigmapMount) GetName() string

func (*ConfigmapMount) ProtoMessage 

func (*ConfigmapMount) ProtoMessage()

func (*ConfigmapMount) ProtoReflect 

func (x *ConfigmapMount) ProtoReflect() protoreflect.Message

func (*ConfigmapMount) Reset 

func (x *ConfigmapMount) Reset()

func (*ConfigmapMount) String 

func (x *ConfigmapMount) String() string

type ConfigmapResponse 

type ConfigmapResponse struct {
	Configmap *Configmap `protobuf:"bytes,1,opt,name=configmap,proto3" json:"configmap,omitempty"`
	Status    *Status    `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ConfigmapResponse) Descriptor deprecated 

func (*ConfigmapResponse) Descriptor() ([]byte, []int)

Deprecated: Use ConfigmapResponse.ProtoReflect.Descriptor instead.

func (*ConfigmapResponse) GetConfigmap 

func (x *ConfigmapResponse) GetConfigmap() *Configmap

func (*ConfigmapResponse) GetStatus 

func (x *ConfigmapResponse) GetStatus() *Status

func (*ConfigmapResponse) ProtoMessage 

func (*ConfigmapResponse) ProtoMessage()

func (*ConfigmapResponse) ProtoReflect 

func (x *ConfigmapResponse) ProtoReflect() protoreflect.Message

func (*ConfigmapResponse) Reset 

func (x *ConfigmapResponse) Reset()

func (*ConfigmapResponse) String 

func (x *ConfigmapResponse) String() string

type ConfigmapServiceClient 

type ConfigmapServiceClient interface {
	CreateConfigmap(ctx context.Context, in *CreateConfigmapRequest, opts ...grpc.CallOption) (*ConfigmapResponse, error)
	GetConfigmap(ctx context.Context, in *GetConfigmapRequest, opts ...grpc.CallOption) (*ConfigmapResponse, error)
	UpdateConfigmap(ctx context.Context, in *UpdateConfigmapRequest, opts ...grpc.CallOption) (*ConfigmapResponse, error)
	DeleteConfigmap(ctx context.Context, in *DeleteConfigmapRequest, opts ...grpc.CallOption) (*Status, error)
	ListConfigmaps(ctx context.Context, in *ListConfigmapsRequest, opts ...grpc.CallOption) (*ListConfigmapsResponse, error)
}

ConfigmapServiceClient is the client API for ConfigmapService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewConfigmapServiceClient 

func NewConfigmapServiceClient(cc grpc.ClientConnInterface) ConfigmapServiceClient

type ConfigmapServiceServer 

type ConfigmapServiceServer interface {
	CreateConfigmap(context.Context, *CreateConfigmapRequest) (*ConfigmapResponse, error)
	GetConfigmap(context.Context, *GetConfigmapRequest) (*ConfigmapResponse, error)
	UpdateConfigmap(context.Context, *UpdateConfigmapRequest) (*ConfigmapResponse, error)
	DeleteConfigmap(context.Context, *DeleteConfigmapRequest) (*Status, error)
	ListConfigmaps(context.Context, *ListConfigmapsRequest) (*ListConfigmapsResponse, error)
	// contains filtered or unexported methods
}

ConfigmapServiceServer is the server API for ConfigmapService service. All implementations must embed UnimplementedConfigmapServiceServer for forward compatibility.

type CreateConfigmapRequest 

type CreateConfigmapRequest struct {
	Configmap       *Configmap `protobuf:"bytes,1,opt,name=configmap,proto3" json:"configmap,omitempty"`
	EnsureNamespace bool       `protobuf:"varint,2,opt,name=ensure_namespace,json=ensureNamespace,proto3" json:"ensure_namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateConfigmapRequest) Descriptor deprecated 

func (*CreateConfigmapRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateConfigmapRequest.ProtoReflect.Descriptor instead.

func (*CreateConfigmapRequest) GetConfigmap 

func (x *CreateConfigmapRequest) GetConfigmap() *Configmap

func (*CreateConfigmapRequest) GetEnsureNamespace 

func (x *CreateConfigmapRequest) GetEnsureNamespace() bool

func (*CreateConfigmapRequest) ProtoMessage 

func (*CreateConfigmapRequest) ProtoMessage()

func (*CreateConfigmapRequest) ProtoReflect 

func (x *CreateConfigmapRequest) ProtoReflect() protoreflect.Message

func (*CreateConfigmapRequest) Reset 

func (x *CreateConfigmapRequest) Reset()

func (*CreateConfigmapRequest) String 

func (x *CreateConfigmapRequest) String() string

type CreateNamespaceRequest 

type CreateNamespaceRequest struct {

	// The namespace to create
	Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

CreateNamespaceRequest is the request for creating a namespace.

func (*CreateNamespaceRequest) Descriptor deprecated 

func (*CreateNamespaceRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateNamespaceRequest.ProtoReflect.Descriptor instead.

func (*CreateNamespaceRequest) GetNamespace 

func (x *CreateNamespaceRequest) GetNamespace() *Namespace

func (*CreateNamespaceRequest) ProtoMessage 

func (*CreateNamespaceRequest) ProtoMessage()

func (*CreateNamespaceRequest) ProtoReflect 

func (x *CreateNamespaceRequest) ProtoReflect() protoreflect.Message

func (*CreateNamespaceRequest) Reset 

func (x *CreateNamespaceRequest) Reset()

func (*CreateNamespaceRequest) String 

func (x *CreateNamespaceRequest) String() string

type CreateNamespaceResponse 

type CreateNamespaceResponse struct {

	// The created namespace
	Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Status information
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

CreateNamespaceResponse is the response for creating a namespace.

func (*CreateNamespaceResponse) Descriptor deprecated 

func (*CreateNamespaceResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateNamespaceResponse.ProtoReflect.Descriptor instead.

func (*CreateNamespaceResponse) GetNamespace 

func (x *CreateNamespaceResponse) GetNamespace() *Namespace

func (*CreateNamespaceResponse) GetStatus 

func (x *CreateNamespaceResponse) GetStatus() *Status

func (*CreateNamespaceResponse) ProtoMessage 

func (*CreateNamespaceResponse) ProtoMessage()

func (*CreateNamespaceResponse) ProtoReflect 

func (x *CreateNamespaceResponse) ProtoReflect() protoreflect.Message

func (*CreateNamespaceResponse) Reset 

func (x *CreateNamespaceResponse) Reset()

func (*CreateNamespaceResponse) String 

func (x *CreateNamespaceResponse) String() string

type CreateSecretRequest 

type CreateSecretRequest struct {
	Secret          *Secret `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	EnsureNamespace bool    `protobuf:"varint,2,opt,name=ensure_namespace,json=ensureNamespace,proto3" json:"ensure_namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateSecretRequest) Descriptor deprecated 

func (*CreateSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateSecretRequest.ProtoReflect.Descriptor instead.

func (*CreateSecretRequest) GetEnsureNamespace 

func (x *CreateSecretRequest) GetEnsureNamespace() bool

func (*CreateSecretRequest) GetSecret 

func (x *CreateSecretRequest) GetSecret() *Secret

func (*CreateSecretRequest) ProtoMessage 

func (*CreateSecretRequest) ProtoMessage()

func (*CreateSecretRequest) ProtoReflect 

func (x *CreateSecretRequest) ProtoReflect() protoreflect.Message

func (*CreateSecretRequest) Reset 

func (x *CreateSecretRequest) Reset()

func (*CreateSecretRequest) String 

func (x *CreateSecretRequest) String() string

type CreateServiceRequest 

type CreateServiceRequest struct {

	// Service to create
	Service *Service `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// Optional deployment tag
	DeploymentTag string `protobuf:"bytes,2,opt,name=deployment_tag,json=deploymentTag,proto3" json:"deployment_tag,omitempty"`
	// Whether to create the namespace if it doesn't exist
	EnsureNamespace bool `protobuf:"varint,3,opt,name=ensure_namespace,json=ensureNamespace,proto3" json:"ensure_namespace,omitempty"`
	// contains filtered or unexported fields
}

CreateServiceRequest represents a request to create a new service.

func (*CreateServiceRequest) Descriptor deprecated 

func (*CreateServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateServiceRequest.ProtoReflect.Descriptor instead.

func (*CreateServiceRequest) GetDeploymentTag 

func (x *CreateServiceRequest) GetDeploymentTag() string

func (*CreateServiceRequest) GetEnsureNamespace 

func (x *CreateServiceRequest) GetEnsureNamespace() bool

func (*CreateServiceRequest) GetService 

func (x *CreateServiceRequest) GetService() *Service

func (*CreateServiceRequest) ProtoMessage 

func (*CreateServiceRequest) ProtoMessage()

func (*CreateServiceRequest) ProtoReflect 

func (x *CreateServiceRequest) ProtoReflect() protoreflect.Message

func (*CreateServiceRequest) Reset 

func (x *CreateServiceRequest) Reset()

func (*CreateServiceRequest) String 

func (x *CreateServiceRequest) String() string

type CreateSnapshotRequest 

type CreateSnapshotRequest struct {
	Snapshot        *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	EnsureNamespace bool      `protobuf:"varint,2,opt,name=ensure_namespace,json=ensureNamespace,proto3" json:"ensure_namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateSnapshotRequest) Descriptor deprecated 

func (*CreateSnapshotRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateSnapshotRequest.ProtoReflect.Descriptor instead.

func (*CreateSnapshotRequest) GetEnsureNamespace 

func (x *CreateSnapshotRequest) GetEnsureNamespace() bool

func (*CreateSnapshotRequest) GetSnapshot 

func (x *CreateSnapshotRequest) GetSnapshot() *Snapshot

func (*CreateSnapshotRequest) ProtoMessage 

func (*CreateSnapshotRequest) ProtoMessage()

func (*CreateSnapshotRequest) ProtoReflect 

func (x *CreateSnapshotRequest) ProtoReflect() protoreflect.Message

func (*CreateSnapshotRequest) Reset 

func (x *CreateSnapshotRequest) Reset()

func (*CreateSnapshotRequest) String 

func (x *CreateSnapshotRequest) String() string

type CreateStorageClassRequest 

type CreateStorageClassRequest struct {
	StorageClass *StorageClass `protobuf:"bytes,1,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateStorageClassRequest) Descriptor deprecated 

func (*CreateStorageClassRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateStorageClassRequest.ProtoReflect.Descriptor instead.

func (*CreateStorageClassRequest) GetStorageClass 

func (x *CreateStorageClassRequest) GetStorageClass() *StorageClass

func (*CreateStorageClassRequest) ProtoMessage 

func (*CreateStorageClassRequest) ProtoMessage()

func (*CreateStorageClassRequest) ProtoReflect 

func (x *CreateStorageClassRequest) ProtoReflect() protoreflect.Message

func (*CreateStorageClassRequest) Reset 

func (x *CreateStorageClassRequest) Reset()

func (*CreateStorageClassRequest) String 

func (x *CreateStorageClassRequest) String() string

type CreateTokenRequest 

type CreateTokenRequest struct {
	Name        string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	SubjectId   string   `protobuf:"bytes,2,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`
	SubjectName string   `protobuf:"bytes,3,opt,name=subject_name,json=subjectName,proto3" json:"subject_name,omitempty"`
	SubjectType string   `protobuf:"bytes,4,opt,name=subject_type,json=subjectType,proto3" json:"subject_type,omitempty"` // user|service
	Policies    []string `protobuf:"bytes,5,rep,name=policies,proto3" json:"policies,omitempty"`                          // repurposed to carry default policies on auto-create
	TtlSeconds  int64    `protobuf:"varint,6,opt,name=ttl_seconds,json=ttlSeconds,proto3" json:"ttl_seconds,omitempty"`   // 0 for no expiry
	Description string   `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateTokenRequest) Descriptor deprecated 

func (*CreateTokenRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateTokenRequest.ProtoReflect.Descriptor instead.

func (*CreateTokenRequest) GetDescription 

func (x *CreateTokenRequest) GetDescription() string

func (*CreateTokenRequest) GetName 

func (x *CreateTokenRequest) GetName() string

func (*CreateTokenRequest) GetPolicies 

func (x *CreateTokenRequest) GetPolicies() []string

func (*CreateTokenRequest) GetSubjectId 

func (x *CreateTokenRequest) GetSubjectId() string

func (*CreateTokenRequest) GetSubjectName 

func (x *CreateTokenRequest) GetSubjectName() string

func (*CreateTokenRequest) GetSubjectType 

func (x *CreateTokenRequest) GetSubjectType() string

func (*CreateTokenRequest) GetTtlSeconds 

func (x *CreateTokenRequest) GetTtlSeconds() int64

func (*CreateTokenRequest) ProtoMessage 

func (*CreateTokenRequest) ProtoMessage()

func (*CreateTokenRequest) ProtoReflect 

func (x *CreateTokenRequest) ProtoReflect() protoreflect.Message

func (*CreateTokenRequest) Reset 

func (x *CreateTokenRequest) Reset()

func (*CreateTokenRequest) String 

func (x *CreateTokenRequest) String() string

type CreateTokenResponse 

type CreateTokenResponse struct {
	Id     string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name   string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Secret string `protobuf:"bytes,3,opt,name=secret,proto3" json:"secret,omitempty"` // returned once
	// contains filtered or unexported fields
}

func (*CreateTokenResponse) Descriptor deprecated 

func (*CreateTokenResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateTokenResponse.ProtoReflect.Descriptor instead.

func (*CreateTokenResponse) GetId 

func (x *CreateTokenResponse) GetId() string

func (*CreateTokenResponse) GetName 

func (x *CreateTokenResponse) GetName() string

func (*CreateTokenResponse) GetSecret 

func (x *CreateTokenResponse) GetSecret() string

func (*CreateTokenResponse) ProtoMessage 

func (*CreateTokenResponse) ProtoMessage()

func (*CreateTokenResponse) ProtoReflect 

func (x *CreateTokenResponse) ProtoReflect() protoreflect.Message

func (*CreateTokenResponse) Reset 

func (x *CreateTokenResponse) Reset()

func (*CreateTokenResponse) String 

func (x *CreateTokenResponse) String() string

type CreateVolumeRequest 

type CreateVolumeRequest struct {
	Volume          *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
	EnsureNamespace bool    `protobuf:"varint,2,opt,name=ensure_namespace,json=ensureNamespace,proto3" json:"ensure_namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateVolumeRequest) Descriptor deprecated 

func (*CreateVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateVolumeRequest) GetEnsureNamespace 

func (x *CreateVolumeRequest) GetEnsureNamespace() bool

func (*CreateVolumeRequest) GetVolume 

func (x *CreateVolumeRequest) GetVolume() *Volume

func (*CreateVolumeRequest) ProtoMessage 

func (*CreateVolumeRequest) ProtoMessage()

func (*CreateVolumeRequest) ProtoReflect 

func (x *CreateVolumeRequest) ProtoReflect() protoreflect.Message

func (*CreateVolumeRequest) Reset 

func (x *CreateVolumeRequest) Reset()

func (*CreateVolumeRequest) String 

func (x *CreateVolumeRequest) String() string

type DeleteConfigmapRequest 

type DeleteConfigmapRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteConfigmapRequest) Descriptor deprecated 

func (*DeleteConfigmapRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteConfigmapRequest.ProtoReflect.Descriptor instead.

func (*DeleteConfigmapRequest) GetName 

func (x *DeleteConfigmapRequest) GetName() string

func (*DeleteConfigmapRequest) GetNamespace 

func (x *DeleteConfigmapRequest) GetNamespace() string

func (*DeleteConfigmapRequest) ProtoMessage 

func (*DeleteConfigmapRequest) ProtoMessage()

func (*DeleteConfigmapRequest) ProtoReflect 

func (x *DeleteConfigmapRequest) ProtoReflect() protoreflect.Message

func (*DeleteConfigmapRequest) Reset 

func (x *DeleteConfigmapRequest) Reset()

func (*DeleteConfigmapRequest) String 

func (x *DeleteConfigmapRequest) String() string

type DeleteNamespaceRequest 

type DeleteNamespaceRequest struct {

	// The name of the namespace to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Whether to ignore if the namespace doesn't exist
	IgnoreNotFound bool `protobuf:"varint,2,opt,name=ignore_not_found,json=ignoreNotFound,proto3" json:"ignore_not_found,omitempty"`
	// Whether to force deletion even if resources exist
	Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// contains filtered or unexported fields
}

DeleteNamespaceRequest is the request for deleting a namespace.

func (*DeleteNamespaceRequest) Descriptor deprecated 

func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteNamespaceRequest.ProtoReflect.Descriptor instead.

func (*DeleteNamespaceRequest) GetForce 

func (x *DeleteNamespaceRequest) GetForce() bool

func (*DeleteNamespaceRequest) GetIgnoreNotFound 

func (x *DeleteNamespaceRequest) GetIgnoreNotFound() bool

func (*DeleteNamespaceRequest) GetName 

func (x *DeleteNamespaceRequest) GetName() string

func (*DeleteNamespaceRequest) ProtoMessage 

func (*DeleteNamespaceRequest) ProtoMessage()

func (*DeleteNamespaceRequest) ProtoReflect 

func (x *DeleteNamespaceRequest) ProtoReflect() protoreflect.Message

func (*DeleteNamespaceRequest) Reset 

func (x *DeleteNamespaceRequest) Reset()

func (*DeleteNamespaceRequest) String 

func (x *DeleteNamespaceRequest) String() string

type DeleteNamespaceResponse 

type DeleteNamespaceResponse struct {

	// Status information
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

DeleteNamespaceResponse is the response for deleting a namespace.

func (*DeleteNamespaceResponse) Descriptor deprecated 

func (*DeleteNamespaceResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteNamespaceResponse.ProtoReflect.Descriptor instead.

func (*DeleteNamespaceResponse) GetStatus 

func (x *DeleteNamespaceResponse) GetStatus() *Status

func (*DeleteNamespaceResponse) ProtoMessage 

func (*DeleteNamespaceResponse) ProtoMessage()

func (*DeleteNamespaceResponse) ProtoReflect 

func (x *DeleteNamespaceResponse) ProtoReflect() protoreflect.Message

func (*DeleteNamespaceResponse) Reset 

func (x *DeleteNamespaceResponse) Reset()

func (*DeleteNamespaceResponse) String 

func (x *DeleteNamespaceResponse) String() string

type DeleteSecretRequest 

type DeleteSecretRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteSecretRequest) Descriptor deprecated 

func (*DeleteSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteSecretRequest.ProtoReflect.Descriptor instead.

func (*DeleteSecretRequest) GetName 

func (x *DeleteSecretRequest) GetName() string

func (*DeleteSecretRequest) GetNamespace 

func (x *DeleteSecretRequest) GetNamespace() string

func (*DeleteSecretRequest) ProtoMessage 

func (*DeleteSecretRequest) ProtoMessage()

func (*DeleteSecretRequest) ProtoReflect 

func (x *DeleteSecretRequest) ProtoReflect() protoreflect.Message

func (*DeleteSecretRequest) Reset 

func (x *DeleteSecretRequest) Reset()

func (*DeleteSecretRequest) String 

func (x *DeleteSecretRequest) String() string

type DeleteServiceRequest 

type DeleteServiceRequest struct {

	// Name of the service to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Force deletion without confirmation
	Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// Timeout for graceful shutdown in seconds
	TimeoutSeconds int32 `protobuf:"varint,4,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	// Detach and return immediately
	Detach bool `protobuf:"varint,5,opt,name=detach,proto3" json:"detach,omitempty"`
	// Dry run mode - show what would be deleted without actually deleting
	DryRun bool `protobuf:"varint,6,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
	// Grace period for graceful shutdown in seconds
	GracePeriod int32 `protobuf:"varint,7,opt,name=grace_period,json=gracePeriod,proto3" json:"grace_period,omitempty"`
	// Immediate deletion without graceful shutdown
	Now bool `protobuf:"varint,8,opt,name=now,proto3" json:"now,omitempty"`
	// Don't error if service doesn't exist
	IgnoreNotFound bool `protobuf:"varint,9,opt,name=ignore_not_found,json=ignoreNotFound,proto3" json:"ignore_not_found,omitempty"`
	// Optional finalizers to run
	Finalizers []string `protobuf:"bytes,10,rep,name=finalizers,proto3" json:"finalizers,omitempty"`
	// Ignore dependents and proceed with deletion (MVP override)
	NoDependencies bool `protobuf:"varint,11,opt,name=no_dependencies,json=noDependencies,proto3" json:"no_dependencies,omitempty"`
	// contains filtered or unexported fields
}

DeleteServiceRequest requests deletion of a service.

func (*DeleteServiceRequest) Descriptor deprecated 

func (*DeleteServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead.

func (*DeleteServiceRequest) GetDetach 

func (x *DeleteServiceRequest) GetDetach() bool

func (*DeleteServiceRequest) GetDryRun 

func (x *DeleteServiceRequest) GetDryRun() bool

func (*DeleteServiceRequest) GetFinalizers 

func (x *DeleteServiceRequest) GetFinalizers() []string

func (*DeleteServiceRequest) GetForce 

func (x *DeleteServiceRequest) GetForce() bool

func (*DeleteServiceRequest) GetGracePeriod 

func (x *DeleteServiceRequest) GetGracePeriod() int32

func (*DeleteServiceRequest) GetIgnoreNotFound 

func (x *DeleteServiceRequest) GetIgnoreNotFound() bool

func (*DeleteServiceRequest) GetName 

func (x *DeleteServiceRequest) GetName() string

func (*DeleteServiceRequest) GetNamespace 

func (x *DeleteServiceRequest) GetNamespace() string

func (*DeleteServiceRequest) GetNoDependencies 

func (x *DeleteServiceRequest) GetNoDependencies() bool

func (*DeleteServiceRequest) GetNow 

func (x *DeleteServiceRequest) GetNow() bool

func (*DeleteServiceRequest) GetTimeoutSeconds 

func (x *DeleteServiceRequest) GetTimeoutSeconds() int32

func (*DeleteServiceRequest) ProtoMessage 

func (*DeleteServiceRequest) ProtoMessage()

func (*DeleteServiceRequest) ProtoReflect 

func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message

func (*DeleteServiceRequest) Reset 

func (x *DeleteServiceRequest) Reset()

func (*DeleteServiceRequest) String 

func (x *DeleteServiceRequest) String() string

type DeleteServiceResponse 

type DeleteServiceResponse struct {

	// ID of the deletion operation
	DeletionId string `protobuf:"bytes,1,opt,name=deletion_id,json=deletionId,proto3" json:"deletion_id,omitempty"`
	// Status of the deletion
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// Warning messages
	Warnings []string `protobuf:"bytes,3,rep,name=warnings,proto3" json:"warnings,omitempty"`
	// Error messages
	Errors []string `protobuf:"bytes,4,rep,name=errors,proto3" json:"errors,omitempty"`
	// Cleanup operations that will be performed
	CleanupOperations []string `protobuf:"bytes,5,rep,name=cleanup_operations,json=cleanupOperations,proto3" json:"cleanup_operations,omitempty"`
	// Whether cleanup was partial
	PartialCleanup bool `protobuf:"varint,6,opt,name=partial_cleanup,json=partialCleanup,proto3" json:"partial_cleanup,omitempty"`
	// Finalizers that will be executed
	Finalizers []*Finalizer `protobuf:"bytes,7,rep,name=finalizers,proto3" json:"finalizers,omitempty"`
	// contains filtered or unexported fields
}

DeleteServiceResponse returns the result of a service deletion.

func (*DeleteServiceResponse) Descriptor deprecated 

func (*DeleteServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead.

func (*DeleteServiceResponse) GetCleanupOperations 

func (x *DeleteServiceResponse) GetCleanupOperations() []string

func (*DeleteServiceResponse) GetDeletionId 

func (x *DeleteServiceResponse) GetDeletionId() string

func (*DeleteServiceResponse) GetErrors 

func (x *DeleteServiceResponse) GetErrors() []string

func (*DeleteServiceResponse) GetFinalizers 

func (x *DeleteServiceResponse) GetFinalizers() []*Finalizer

func (*DeleteServiceResponse) GetPartialCleanup 

func (x *DeleteServiceResponse) GetPartialCleanup() bool

func (*DeleteServiceResponse) GetStatus 

func (x *DeleteServiceResponse) GetStatus() *Status

func (*DeleteServiceResponse) GetWarnings 

func (x *DeleteServiceResponse) GetWarnings() []string

func (*DeleteServiceResponse) ProtoMessage 

func (*DeleteServiceResponse) ProtoMessage()

func (*DeleteServiceResponse) ProtoReflect 

func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message

func (*DeleteServiceResponse) Reset 

func (x *DeleteServiceResponse) Reset()

func (*DeleteServiceResponse) String 

func (x *DeleteServiceResponse) String() string

type DeleteSnapshotRequest 

type DeleteSnapshotRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteSnapshotRequest) Descriptor deprecated 

func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteSnapshotRequest.ProtoReflect.Descriptor instead.

func (*DeleteSnapshotRequest) GetName 

func (x *DeleteSnapshotRequest) GetName() string

func (*DeleteSnapshotRequest) GetNamespace 

func (x *DeleteSnapshotRequest) GetNamespace() string

func (*DeleteSnapshotRequest) ProtoMessage 

func (*DeleteSnapshotRequest) ProtoMessage()

func (*DeleteSnapshotRequest) ProtoReflect 

func (x *DeleteSnapshotRequest) ProtoReflect() protoreflect.Message

func (*DeleteSnapshotRequest) Reset 

func (x *DeleteSnapshotRequest) Reset()

func (*DeleteSnapshotRequest) String 

func (x *DeleteSnapshotRequest) String() string

type DeleteStorageClassRequest 

type DeleteStorageClassRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Cascade bypasses the in-use safety check. Without it, deletion is
	// refused when any Volume still references this StorageClass; with it,
	// the StorageClass is removed even if dependent volumes exist (the
	// volumes themselves are NOT deleted — they keep a now-dangling
	// StorageClassName until the operator addresses them).
	Cascade bool `protobuf:"varint,2,opt,name=cascade,proto3" json:"cascade,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteStorageClassRequest) Descriptor deprecated 

func (*DeleteStorageClassRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteStorageClassRequest.ProtoReflect.Descriptor instead.

func (*DeleteStorageClassRequest) GetCascade 

func (x *DeleteStorageClassRequest) GetCascade() bool

func (*DeleteStorageClassRequest) GetName 

func (x *DeleteStorageClassRequest) GetName() string

func (*DeleteStorageClassRequest) ProtoMessage 

func (*DeleteStorageClassRequest) ProtoMessage()

func (*DeleteStorageClassRequest) ProtoReflect 

func (x *DeleteStorageClassRequest) ProtoReflect() protoreflect.Message

func (*DeleteStorageClassRequest) Reset 

func (x *DeleteStorageClassRequest) Reset()

func (*DeleteStorageClassRequest) String 

func (x *DeleteStorageClassRequest) String() string

type DeleteVolumeRequest 

type DeleteVolumeRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteVolumeRequest) Descriptor deprecated 

func (*DeleteVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteVolumeRequest) GetName 

func (x *DeleteVolumeRequest) GetName() string

func (*DeleteVolumeRequest) GetNamespace 

func (x *DeleteVolumeRequest) GetNamespace() string

func (*DeleteVolumeRequest) ProtoMessage 

func (*DeleteVolumeRequest) ProtoMessage()

func (*DeleteVolumeRequest) ProtoReflect 

func (x *DeleteVolumeRequest) ProtoReflect() protoreflect.Message

func (*DeleteVolumeRequest) Reset 

func (x *DeleteVolumeRequest) Reset()

func (*DeleteVolumeRequest) String 

func (x *DeleteVolumeRequest) String() string

type DeletionOperation 

type DeletionOperation struct {
	Id                  string       `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Namespace           string       `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ServiceName         string       `protobuf:"bytes,3,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	TotalInstances      int32        `protobuf:"varint,4,opt,name=total_instances,json=totalInstances,proto3" json:"total_instances,omitempty"`
	DeletedInstances    int32        `protobuf:"varint,5,opt,name=deleted_instances,json=deletedInstances,proto3" json:"deleted_instances,omitempty"`
	FailedInstances     int32        `protobuf:"varint,6,opt,name=failed_instances,json=failedInstances,proto3" json:"failed_instances,omitempty"`
	StartTime           int64        `protobuf:"varint,7,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	EndTime             int64        `protobuf:"varint,8,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	Status              string       `protobuf:"bytes,9,opt,name=status,proto3" json:"status,omitempty"`
	FailureReason       string       `protobuf:"bytes,10,opt,name=failure_reason,json=failureReason,proto3" json:"failure_reason,omitempty"`
	PendingOperations   []string     `protobuf:"bytes,11,rep,name=pending_operations,json=pendingOperations,proto3" json:"pending_operations,omitempty"`
	EstimatedCompletion int64        `protobuf:"varint,12,opt,name=estimated_completion,json=estimatedCompletion,proto3" json:"estimated_completion,omitempty"`
	Finalizers          []*Finalizer `protobuf:"bytes,13,rep,name=finalizers,proto3" json:"finalizers,omitempty"`
	FinalizerOrder      []string     `protobuf:"bytes,14,rep,name=finalizer_order,json=finalizerOrder,proto3" json:"finalizer_order,omitempty"`
	FinalizerStatus     string       `protobuf:"bytes,15,opt,name=finalizer_status,json=finalizerStatus,proto3" json:"finalizer_status,omitempty"`
	// contains filtered or unexported fields
}

DeletionOperation represents a deletion operation for a service

func (*DeletionOperation) Descriptor deprecated 

func (*DeletionOperation) Descriptor() ([]byte, []int)

Deprecated: Use DeletionOperation.ProtoReflect.Descriptor instead.

func (*DeletionOperation) GetDeletedInstances 

func (x *DeletionOperation) GetDeletedInstances() int32

func (*DeletionOperation) GetEndTime 

func (x *DeletionOperation) GetEndTime() int64

func (*DeletionOperation) GetEstimatedCompletion 

func (x *DeletionOperation) GetEstimatedCompletion() int64

func (*DeletionOperation) GetFailedInstances 

func (x *DeletionOperation) GetFailedInstances() int32

func (*DeletionOperation) GetFailureReason 

func (x *DeletionOperation) GetFailureReason() string

func (*DeletionOperation) GetFinalizerOrder 

func (x *DeletionOperation) GetFinalizerOrder() []string

func (*DeletionOperation) GetFinalizerStatus 

func (x *DeletionOperation) GetFinalizerStatus() string

func (*DeletionOperation) GetFinalizers 

func (x *DeletionOperation) GetFinalizers() []*Finalizer

func (*DeletionOperation) GetId 

func (x *DeletionOperation) GetId() string

func (*DeletionOperation) GetNamespace 

func (x *DeletionOperation) GetNamespace() string

func (*DeletionOperation) GetPendingOperations 

func (x *DeletionOperation) GetPendingOperations() []string

func (*DeletionOperation) GetServiceName 

func (x *DeletionOperation) GetServiceName() string

func (*DeletionOperation) GetStartTime 

func (x *DeletionOperation) GetStartTime() int64

func (*DeletionOperation) GetStatus 

func (x *DeletionOperation) GetStatus() string

func (*DeletionOperation) GetTotalInstances 

func (x *DeletionOperation) GetTotalInstances() int32

func (*DeletionOperation) ProtoMessage 

func (*DeletionOperation) ProtoMessage()

func (*DeletionOperation) ProtoReflect 

func (x *DeletionOperation) ProtoReflect() protoreflect.Message

func (*DeletionOperation) Reset 

func (x *DeletionOperation) Reset()

func (*DeletionOperation) String 

func (x *DeletionOperation) String() string

type DependencyRef 

type DependencyRef struct {

	// Exactly one of service/secret/configmap should be set. Namespace optional.
	Service   string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Secret    string `protobuf:"bytes,3,opt,name=secret,proto3" json:"secret,omitempty"`
	Configmap string `protobuf:"bytes,4,opt,name=configmap,proto3" json:"configmap,omitempty"`
	// contains filtered or unexported fields
}

DependencyRef represents a dependency on another service

func (*DependencyRef) Descriptor deprecated 

func (*DependencyRef) Descriptor() ([]byte, []int)

Deprecated: Use DependencyRef.ProtoReflect.Descriptor instead.

func (*DependencyRef) GetConfigmap 

func (x *DependencyRef) GetConfigmap() string

func (*DependencyRef) GetNamespace 

func (x *DependencyRef) GetNamespace() string

func (*DependencyRef) GetSecret 

func (x *DependencyRef) GetSecret() string

func (*DependencyRef) GetService 

func (x *DependencyRef) GetService() string

func (*DependencyRef) ProtoMessage 

func (*DependencyRef) ProtoMessage()

func (*DependencyRef) ProtoReflect 

func (x *DependencyRef) ProtoReflect() protoreflect.Message

func (*DependencyRef) Reset 

func (x *DependencyRef) Reset()

func (*DependencyRef) String 

func (x *DependencyRef) String() string

type DetachVolumeRequest 

type DetachVolumeRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Force     bool   `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// contains filtered or unexported fields
}

DetachVolumeRequest clears bind state on a volume so a replacement instance may attach it. Without force the volume must already be Released (or never bound). With force=true the bind state is cleared regardless of current status — caller assumes responsibility for any data-loss risk if the previous holder is still alive.

func (*DetachVolumeRequest) Descriptor deprecated 

func (*DetachVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use DetachVolumeRequest.ProtoReflect.Descriptor instead.

func (*DetachVolumeRequest) GetForce 

func (x *DetachVolumeRequest) GetForce() bool

func (*DetachVolumeRequest) GetName 

func (x *DetachVolumeRequest) GetName() string

func (*DetachVolumeRequest) GetNamespace 

func (x *DetachVolumeRequest) GetNamespace() string

func (*DetachVolumeRequest) ProtoMessage 

func (*DetachVolumeRequest) ProtoMessage()

func (*DetachVolumeRequest) ProtoReflect 

func (x *DetachVolumeRequest) ProtoReflect() protoreflect.Message

func (*DetachVolumeRequest) Reset 

func (x *DetachVolumeRequest) Reset()

func (*DetachVolumeRequest) String 

func (x *DetachVolumeRequest) String() string

type Empty 

type Empty struct {
	// contains filtered or unexported fields
}

Empty request or response

func (*Empty) Descriptor deprecated 

func (*Empty) Descriptor() ([]byte, []int)

Deprecated: Use Empty.ProtoReflect.Descriptor instead.

func (*Empty) ProtoMessage 

func (*Empty) ProtoMessage()

func (*Empty) ProtoReflect 

func (x *Empty) ProtoReflect() protoreflect.Message

func (*Empty) Reset 

func (x *Empty) Reset()

func (*Empty) String 

func (x *Empty) String() string

type EnvFromSource 

type EnvFromSource struct {

	// Exactly one of these will be set
	SecretName    string `protobuf:"bytes,1,opt,name=secret_name,json=secretName,proto3" json:"secret_name,omitempty"`
	ConfigmapName string `protobuf:"bytes,2,opt,name=configmap_name,json=configmapName,proto3" json:"configmap_name,omitempty"`
	Namespace     string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Prefix        string `protobuf:"bytes,4,opt,name=prefix,proto3" json:"prefix,omitempty"`
	// contains filtered or unexported fields
}

EnvFromSource represents an environment import source

func (*EnvFromSource) Descriptor deprecated 

func (*EnvFromSource) Descriptor() ([]byte, []int)

Deprecated: Use EnvFromSource.ProtoReflect.Descriptor instead.

func (*EnvFromSource) GetConfigmapName 

func (x *EnvFromSource) GetConfigmapName() string

func (*EnvFromSource) GetNamespace 

func (x *EnvFromSource) GetNamespace() string

func (*EnvFromSource) GetPrefix 

func (x *EnvFromSource) GetPrefix() string

func (*EnvFromSource) GetSecretName 

func (x *EnvFromSource) GetSecretName() string

func (*EnvFromSource) ProtoMessage 

func (*EnvFromSource) ProtoMessage()

func (*EnvFromSource) ProtoReflect 

func (x *EnvFromSource) ProtoReflect() protoreflect.Message

func (*EnvFromSource) Reset 

func (x *EnvFromSource) Reset()

func (*EnvFromSource) String 

func (x *EnvFromSource) String() string

type EventType 

type EventType int32

EventType represents the type of event in a watch stream 

const (
	EventType_EVENT_TYPE_UNSPECIFIED EventType = 0
	EventType_EVENT_TYPE_ADDED       EventType = 1 // Resource was added
	EventType_EVENT_TYPE_MODIFIED    EventType = 2 // Resource was modified
	EventType_EVENT_TYPE_DELETED     EventType = 3 // Resource was deleted
)

func (EventType) Descriptor 

func (EventType) Descriptor() protoreflect.EnumDescriptor

func (EventType) Enum 

func (x EventType) Enum() *EventType

func (EventType) EnumDescriptor deprecated 

func (EventType) EnumDescriptor() ([]byte, []int)

Deprecated: Use EventType.Descriptor instead.

func (EventType) Number 

func (x EventType) Number() protoreflect.EnumNumber

func (EventType) String 

func (x EventType) String() string

func (EventType) Type 

func (EventType) Type() protoreflect.EnumType

type ExecInitRequest 

type ExecInitRequest struct {

	// Target instance or service
	//
	// Types that are valid to be assigned to Target:
	//
	//	*ExecInitRequest_ServiceName
	//	*ExecInitRequest_InstanceId
	Target isExecInitRequest_Target `protobuf_oneof:"target"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Command to execute
	Command []string `protobuf:"bytes,4,rep,name=command,proto3" json:"command,omitempty"`
	// Environment variables for the command
	Env map[string]string `` /* 133-byte string literal not displayed */
	// Working directory for the command
	WorkingDir string `protobuf:"bytes,6,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"`
	// Whether to allocate a TTY
	Tty bool `protobuf:"varint,7,opt,name=tty,proto3" json:"tty,omitempty"`
	// Initial terminal size if TTY is true
	TerminalSize *TerminalSize `protobuf:"bytes,8,opt,name=terminal_size,json=terminalSize,proto3" json:"terminal_size,omitempty"`
	// contains filtered or unexported fields
}

ExecInitRequest initializes an exec session.

func (*ExecInitRequest) Descriptor deprecated 

func (*ExecInitRequest) Descriptor() ([]byte, []int)

Deprecated: Use ExecInitRequest.ProtoReflect.Descriptor instead.

func (*ExecInitRequest) GetCommand 

func (x *ExecInitRequest) GetCommand() []string

func (*ExecInitRequest) GetEnv 

func (x *ExecInitRequest) GetEnv() map[string]string

func (*ExecInitRequest) GetInstanceId 

func (x *ExecInitRequest) GetInstanceId() string

func (*ExecInitRequest) GetNamespace 

func (x *ExecInitRequest) GetNamespace() string

func (*ExecInitRequest) GetServiceName 

func (x *ExecInitRequest) GetServiceName() string

func (*ExecInitRequest) GetTarget 

func (x *ExecInitRequest) GetTarget() isExecInitRequest_Target

func (*ExecInitRequest) GetTerminalSize 

func (x *ExecInitRequest) GetTerminalSize() *TerminalSize

func (*ExecInitRequest) GetTty 

func (x *ExecInitRequest) GetTty() bool

func (*ExecInitRequest) GetWorkingDir 

func (x *ExecInitRequest) GetWorkingDir() string

func (*ExecInitRequest) ProtoMessage 

func (*ExecInitRequest) ProtoMessage()

func (*ExecInitRequest) ProtoReflect 

func (x *ExecInitRequest) ProtoReflect() protoreflect.Message

func (*ExecInitRequest) Reset 

func (x *ExecInitRequest) Reset()

func (*ExecInitRequest) String 

func (x *ExecInitRequest) String() string

type ExecInitRequest_InstanceId 

type ExecInitRequest_InstanceId struct {
	// Specific instance ID
	InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3,oneof"`
}

type ExecInitRequest_ServiceName 

type ExecInitRequest_ServiceName struct {
	// Service name (will select one instance)
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3,oneof"`
}

type ExecRequest 

type ExecRequest struct {

	// Request can be one of the following
	//
	// Types that are valid to be assigned to Request:
	//
	//	*ExecRequest_Init
	//	*ExecRequest_Stdin
	//	*ExecRequest_Resize
	//	*ExecRequest_Signal
	Request isExecRequest_Request `protobuf_oneof:"request"`
	// contains filtered or unexported fields
}

ExecRequest represents a request from client to server in an exec session.

func (*ExecRequest) Descriptor deprecated 

func (*ExecRequest) Descriptor() ([]byte, []int)

Deprecated: Use ExecRequest.ProtoReflect.Descriptor instead.

func (*ExecRequest) GetInit 

func (x *ExecRequest) GetInit() *ExecInitRequest

func (*ExecRequest) GetRequest 

func (x *ExecRequest) GetRequest() isExecRequest_Request

func (*ExecRequest) GetResize 

func (x *ExecRequest) GetResize() *TerminalSize

func (*ExecRequest) GetSignal 

func (x *ExecRequest) GetSignal() *Signal

func (*ExecRequest) GetStdin 

func (x *ExecRequest) GetStdin() []byte

func (*ExecRequest) ProtoMessage 

func (*ExecRequest) ProtoMessage()

func (*ExecRequest) ProtoReflect 

func (x *ExecRequest) ProtoReflect() protoreflect.Message

func (*ExecRequest) Reset 

func (x *ExecRequest) Reset()

func (*ExecRequest) String 

func (x *ExecRequest) String() string

type ExecRequest_Init 

type ExecRequest_Init struct {
	// Initial setup for the exec session
	Init *ExecInitRequest `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ExecRequest_Resize 

type ExecRequest_Resize struct {
	// Terminal resize event
	Resize *TerminalSize `protobuf:"bytes,3,opt,name=resize,proto3,oneof"`
}

type ExecRequest_Signal 

type ExecRequest_Signal struct {
	// Signal to send to the process
	Signal *Signal `protobuf:"bytes,4,opt,name=signal,proto3,oneof"`
}

type ExecRequest_Stdin 

type ExecRequest_Stdin struct {
	// Standard input data to send to the process
	Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3,oneof"`
}

type ExecResponse 

type ExecResponse struct {

	// Response can be one of the following
	//
	// Types that are valid to be assigned to Response:
	//
	//	*ExecResponse_Stdout
	//	*ExecResponse_Stderr
	//	*ExecResponse_Status
	//	*ExecResponse_Exit
	Response isExecResponse_Response `protobuf_oneof:"response"`
	// contains filtered or unexported fields
}

ExecResponse represents a response from server to client in an exec session.

func (*ExecResponse) Descriptor deprecated 

func (*ExecResponse) Descriptor() ([]byte, []int)

Deprecated: Use ExecResponse.ProtoReflect.Descriptor instead.

func (*ExecResponse) GetExit 

func (x *ExecResponse) GetExit() *ExitInfo

func (*ExecResponse) GetResponse 

func (x *ExecResponse) GetResponse() isExecResponse_Response

func (*ExecResponse) GetStatus 

func (x *ExecResponse) GetStatus() *Status

func (*ExecResponse) GetStderr 

func (x *ExecResponse) GetStderr() []byte

func (*ExecResponse) GetStdout 

func (x *ExecResponse) GetStdout() []byte

func (*ExecResponse) ProtoMessage 

func (*ExecResponse) ProtoMessage()

func (*ExecResponse) ProtoReflect 

func (x *ExecResponse) ProtoReflect() protoreflect.Message

func (*ExecResponse) Reset 

func (x *ExecResponse) Reset()

func (*ExecResponse) String 

func (x *ExecResponse) String() string

type ExecResponse_Exit 

type ExecResponse_Exit struct {
	// Exit information when the process completes
	Exit *ExitInfo `protobuf:"bytes,4,opt,name=exit,proto3,oneof"`
}

type ExecResponse_Status 

type ExecResponse_Status struct {
	// Status message (for errors, completion, etc.)
	Status *Status `protobuf:"bytes,3,opt,name=status,proto3,oneof"`
}

type ExecResponse_Stderr 

type ExecResponse_Stderr struct {
	// Standard error from the process
	Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type ExecResponse_Stdout 

type ExecResponse_Stdout struct {
	// Standard output from the process
	Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type ExecServiceClient 

type ExecServiceClient interface {
	// StreamExec provides bidirectional streaming for exec.
	StreamExec(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[ExecRequest, ExecResponse], error)
}

ExecServiceClient is the client API for ExecService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

ExecService provides interactive terminal sessions with instances.

func NewExecServiceClient 

func NewExecServiceClient(cc grpc.ClientConnInterface) ExecServiceClient

type ExecServiceServer 

type ExecServiceServer interface {
	// StreamExec provides bidirectional streaming for exec.
	StreamExec(grpc.BidiStreamingServer[ExecRequest, ExecResponse]) error
	// contains filtered or unexported methods
}

ExecServiceServer is the server API for ExecService service. All implementations must embed UnimplementedExecServiceServer for forward compatibility.

ExecService provides interactive terminal sessions with instances.

type ExecService_StreamExecClient 

type ExecService_StreamExecClient = grpc.BidiStreamingClient[ExecRequest, ExecResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ExecService_StreamExecServer 

type ExecService_StreamExecServer = grpc.BidiStreamingServer[ExecRequest, ExecResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ExitInfo 

type ExitInfo struct {

	// Exit code of the process
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// Whether the process exited due to a signal
	Signaled bool `protobuf:"varint,2,opt,name=signaled,proto3" json:"signaled,omitempty"`
	// Signal that caused the exit, if signaled is true
	Signal string `protobuf:"bytes,3,opt,name=signal,proto3" json:"signal,omitempty"`
	// contains filtered or unexported fields
}

ExitInfo provides information about the process exit.

func (*ExitInfo) Descriptor deprecated 

func (*ExitInfo) Descriptor() ([]byte, []int)

Deprecated: Use ExitInfo.ProtoReflect.Descriptor instead.

func (*ExitInfo) GetCode 

func (x *ExitInfo) GetCode() int32

func (*ExitInfo) GetSignal 

func (x *ExitInfo) GetSignal() string

func (*ExitInfo) GetSignaled 

func (x *ExitInfo) GetSignaled() bool

func (*ExitInfo) ProtoMessage 

func (*ExitInfo) ProtoMessage()

func (*ExitInfo) ProtoReflect 

func (x *ExitInfo) ProtoReflect() protoreflect.Message

func (*ExitInfo) Reset 

func (x *ExitInfo) Reset()

func (*ExitInfo) String 

func (x *ExitInfo) String() string

type ExposeServiceTLS 

type ExposeServiceTLS struct {

	// Name of a Secret resource holding tls.crt + tls.key for
	// operator-supplied certificates.
	SecretName string `protobuf:"bytes,1,opt,name=secret_name,json=secretName,proto3" json:"secret_name,omitempty"`
	// Legacy boolean equivalent to mode = "acme". Kept for wire
	// compatibility with older clients.
	Auto bool `protobuf:"varint,2,opt,name=auto,proto3" json:"auto,omitempty"`
	// Provisioning mode. Recognised values: "manual" (default,
	// operator-supplied), "acme" (ACME issuance), "auto" (synonym
	// for "acme").
	Mode string `protobuf:"bytes,3,opt,name=mode,proto3" json:"mode,omitempty"`
	// contains filtered or unexported fields
}

ExposeServiceTLS controls how the ingress terminates TLS for an exposed service. The fields are mutually informative: setting `mode = "acme"` (or `mode = "auto"`) requests an ACME-issued certificate from the configured provider; `secret_name` points at an operator-supplied cert; the legacy `auto` boolean is equivalent to `mode = "acme"` when no mode is set.

func (*ExposeServiceTLS) Descriptor deprecated 

func (*ExposeServiceTLS) Descriptor() ([]byte, []int)

Deprecated: Use ExposeServiceTLS.ProtoReflect.Descriptor instead.

func (*ExposeServiceTLS) GetAuto 

func (x *ExposeServiceTLS) GetAuto() bool

func (*ExposeServiceTLS) GetMode 

func (x *ExposeServiceTLS) GetMode() string

func (*ExposeServiceTLS) GetSecretName 

func (x *ExposeServiceTLS) GetSecretName() string

func (*ExposeServiceTLS) ProtoMessage 

func (*ExposeServiceTLS) ProtoMessage()

func (*ExposeServiceTLS) ProtoReflect 

func (x *ExposeServiceTLS) ProtoReflect() protoreflect.Message

func (*ExposeServiceTLS) Reset 

func (x *ExposeServiceTLS) Reset()

func (*ExposeServiceTLS) String 

func (x *ExposeServiceTLS) String() string

type Finalizer 

type Finalizer struct {
	Id           string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name         string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Type         string                 `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	Status       string                 `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	Error        string                 `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`
	Dependencies []*FinalizerDependency `protobuf:"bytes,6,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	CreatedAt    int64                  `protobuf:"varint,7,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt    int64                  `protobuf:"varint,8,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	CompletedAt  int64                  `protobuf:"varint,9,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
	// contains filtered or unexported fields
}

Finalizer represents a cleanup operation that must complete before deletion

func (*Finalizer) Descriptor deprecated 

func (*Finalizer) Descriptor() ([]byte, []int)

Deprecated: Use Finalizer.ProtoReflect.Descriptor instead.

func (*Finalizer) GetCompletedAt 

func (x *Finalizer) GetCompletedAt() int64

func (*Finalizer) GetCreatedAt 

func (x *Finalizer) GetCreatedAt() int64

func (*Finalizer) GetDependencies 

func (x *Finalizer) GetDependencies() []*FinalizerDependency

func (*Finalizer) GetError 

func (x *Finalizer) GetError() string

func (*Finalizer) GetId 

func (x *Finalizer) GetId() string

func (*Finalizer) GetName 

func (x *Finalizer) GetName() string

func (*Finalizer) GetStatus 

func (x *Finalizer) GetStatus() string

func (*Finalizer) GetType 

func (x *Finalizer) GetType() string

func (*Finalizer) GetUpdatedAt 

func (x *Finalizer) GetUpdatedAt() int64

func (*Finalizer) ProtoMessage 

func (*Finalizer) ProtoMessage()

func (*Finalizer) ProtoReflect 

func (x *Finalizer) ProtoReflect() protoreflect.Message

func (*Finalizer) Reset 

func (x *Finalizer) Reset()

func (*Finalizer) String 

func (x *Finalizer) String() string

type FinalizerDependency 

type FinalizerDependency struct {
	DependsOn string `protobuf:"bytes,1,opt,name=depends_on,json=dependsOn,proto3" json:"depends_on,omitempty"`
	Required  bool   `protobuf:"varint,2,opt,name=required,proto3" json:"required,omitempty"`
	// contains filtered or unexported fields
}

FinalizerDependency represents a dependency between finalizers

func (*FinalizerDependency) Descriptor deprecated 

func (*FinalizerDependency) Descriptor() ([]byte, []int)

Deprecated: Use FinalizerDependency.ProtoReflect.Descriptor instead.

func (*FinalizerDependency) GetDependsOn 

func (x *FinalizerDependency) GetDependsOn() string

func (*FinalizerDependency) GetRequired 

func (x *FinalizerDependency) GetRequired() bool

func (*FinalizerDependency) ProtoMessage 

func (*FinalizerDependency) ProtoMessage()

func (*FinalizerDependency) ProtoReflect 

func (x *FinalizerDependency) ProtoReflect() protoreflect.Message

func (*FinalizerDependency) Reset 

func (x *FinalizerDependency) Reset()

func (*FinalizerDependency) String 

func (x *FinalizerDependency) String() string

type GetConfigmapRequest 

type GetConfigmapRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*GetConfigmapRequest) Descriptor deprecated 

func (*GetConfigmapRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetConfigmapRequest.ProtoReflect.Descriptor instead.

func (*GetConfigmapRequest) GetName 

func (x *GetConfigmapRequest) GetName() string

func (*GetConfigmapRequest) GetNamespace 

func (x *GetConfigmapRequest) GetNamespace() string

func (*GetConfigmapRequest) ProtoMessage 

func (*GetConfigmapRequest) ProtoMessage()

func (*GetConfigmapRequest) ProtoReflect 

func (x *GetConfigmapRequest) ProtoReflect() protoreflect.Message

func (*GetConfigmapRequest) Reset 

func (x *GetConfigmapRequest) Reset()

func (*GetConfigmapRequest) String 

func (x *GetConfigmapRequest) String() string

type GetDeletionStatusRequest 

type GetDeletionStatusRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name      string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

GetDeletionStatusRequest represents a request to get deletion status

func (*GetDeletionStatusRequest) Descriptor deprecated 

func (*GetDeletionStatusRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetDeletionStatusRequest.ProtoReflect.Descriptor instead.

func (*GetDeletionStatusRequest) GetName 

func (x *GetDeletionStatusRequest) GetName() string

func (*GetDeletionStatusRequest) GetNamespace 

func (x *GetDeletionStatusRequest) GetNamespace() string

func (*GetDeletionStatusRequest) ProtoMessage 

func (*GetDeletionStatusRequest) ProtoMessage()

func (*GetDeletionStatusRequest) ProtoReflect 

func (x *GetDeletionStatusRequest) ProtoReflect() protoreflect.Message

func (*GetDeletionStatusRequest) Reset 

func (x *GetDeletionStatusRequest) Reset()

func (*GetDeletionStatusRequest) String 

func (x *GetDeletionStatusRequest) String() string

type GetDeletionStatusResponse 

type GetDeletionStatusResponse struct {
	Operation *DeletionOperation `protobuf:"bytes,1,opt,name=operation,proto3" json:"operation,omitempty"`
	// contains filtered or unexported fields
}

GetDeletionStatusResponse represents the response from getting deletion status

func (*GetDeletionStatusResponse) Descriptor deprecated 

func (*GetDeletionStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetDeletionStatusResponse.ProtoReflect.Descriptor instead.

func (*GetDeletionStatusResponse) GetOperation 

func (x *GetDeletionStatusResponse) GetOperation() *DeletionOperation

func (*GetDeletionStatusResponse) ProtoMessage 

func (*GetDeletionStatusResponse) ProtoMessage()

func (*GetDeletionStatusResponse) ProtoReflect 

func (x *GetDeletionStatusResponse) ProtoReflect() protoreflect.Message

func (*GetDeletionStatusResponse) Reset 

func (x *GetDeletionStatusResponse) Reset()

func (*GetDeletionStatusResponse) String 

func (x *GetDeletionStatusResponse) String() string

type GetHealthRequest 

type GetHealthRequest struct {

	// Component type to check (e.g., "service", "instance", "node", "api-server")
	ComponentType string `protobuf:"bytes,1,opt,name=component_type,json=componentType,proto3" json:"component_type,omitempty"`
	// Component name to check (optional)
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace of the component (if applicable)
	Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Include detailed check results
	IncludeChecks bool `protobuf:"varint,4,opt,name=include_checks,json=includeChecks,proto3" json:"include_checks,omitempty"`
	// contains filtered or unexported fields
}

GetHealthRequest requests health information.

func (*GetHealthRequest) Descriptor deprecated 

func (*GetHealthRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetHealthRequest.ProtoReflect.Descriptor instead.

func (*GetHealthRequest) GetComponentType 

func (x *GetHealthRequest) GetComponentType() string

func (*GetHealthRequest) GetIncludeChecks 

func (x *GetHealthRequest) GetIncludeChecks() bool

func (*GetHealthRequest) GetName 

func (x *GetHealthRequest) GetName() string

func (*GetHealthRequest) GetNamespace 

func (x *GetHealthRequest) GetNamespace() string

func (*GetHealthRequest) ProtoMessage 

func (*GetHealthRequest) ProtoMessage()

func (*GetHealthRequest) ProtoReflect 

func (x *GetHealthRequest) ProtoReflect() protoreflect.Message

func (*GetHealthRequest) Reset 

func (x *GetHealthRequest) Reset()

func (*GetHealthRequest) String 

func (x *GetHealthRequest) String() string

type GetHealthResponse 

type GetHealthResponse struct {

	// Health information of the requested components
	Components []*ComponentHealth `protobuf:"bytes,1,rep,name=components,proto3" json:"components,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

GetHealthResponse returns health information.

func (*GetHealthResponse) Descriptor deprecated 

func (*GetHealthResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetHealthResponse.ProtoReflect.Descriptor instead.

func (*GetHealthResponse) GetComponents 

func (x *GetHealthResponse) GetComponents() []*ComponentHealth

func (*GetHealthResponse) GetStatus 

func (x *GetHealthResponse) GetStatus() *Status

func (*GetHealthResponse) ProtoMessage 

func (*GetHealthResponse) ProtoMessage()

func (*GetHealthResponse) ProtoReflect 

func (x *GetHealthResponse) ProtoReflect() protoreflect.Message

func (*GetHealthResponse) Reset 

func (x *GetHealthResponse) Reset()

func (*GetHealthResponse) String 

func (x *GetHealthResponse) String() string

type GetInstanceRequest 

type GetInstanceRequest struct {

	// ID of the instance
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Namespace of the instance
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

GetInstanceRequest requests a specific instance.

func (*GetInstanceRequest) Descriptor deprecated 

func (*GetInstanceRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetInstanceRequest.ProtoReflect.Descriptor instead.

func (*GetInstanceRequest) GetId 

func (x *GetInstanceRequest) GetId() string

func (*GetInstanceRequest) GetNamespace 

func (x *GetInstanceRequest) GetNamespace() string

func (*GetInstanceRequest) ProtoMessage 

func (*GetInstanceRequest) ProtoMessage()

func (*GetInstanceRequest) ProtoReflect 

func (x *GetInstanceRequest) ProtoReflect() protoreflect.Message

func (*GetInstanceRequest) Reset 

func (x *GetInstanceRequest) Reset()

func (*GetInstanceRequest) String 

func (x *GetInstanceRequest) String() string

type GetNamespaceRequest 

type GetNamespaceRequest struct {

	// The name of the namespace to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

GetNamespaceRequest is the request for getting a namespace.

func (*GetNamespaceRequest) Descriptor deprecated 

func (*GetNamespaceRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetNamespaceRequest.ProtoReflect.Descriptor instead.

func (*GetNamespaceRequest) GetName 

func (x *GetNamespaceRequest) GetName() string

func (*GetNamespaceRequest) ProtoMessage 

func (*GetNamespaceRequest) ProtoMessage()

func (*GetNamespaceRequest) ProtoReflect 

func (x *GetNamespaceRequest) ProtoReflect() protoreflect.Message

func (*GetNamespaceRequest) Reset 

func (x *GetNamespaceRequest) Reset()

func (*GetNamespaceRequest) String 

func (x *GetNamespaceRequest) String() string

type GetNamespaceResponse 

type GetNamespaceResponse struct {

	// The namespace
	Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Status information
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

GetNamespaceResponse is the response for getting a namespace.

func (*GetNamespaceResponse) Descriptor deprecated 

func (*GetNamespaceResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetNamespaceResponse.ProtoReflect.Descriptor instead.

func (*GetNamespaceResponse) GetNamespace 

func (x *GetNamespaceResponse) GetNamespace() *Namespace

func (*GetNamespaceResponse) GetStatus 

func (x *GetNamespaceResponse) GetStatus() *Status

func (*GetNamespaceResponse) ProtoMessage 

func (*GetNamespaceResponse) ProtoMessage()

func (*GetNamespaceResponse) ProtoReflect 

func (x *GetNamespaceResponse) ProtoReflect() protoreflect.Message

func (*GetNamespaceResponse) Reset 

func (x *GetNamespaceResponse) Reset()

func (*GetNamespaceResponse) String 

func (x *GetNamespaceResponse) String() string

type GetRegistryRequest 

type GetRegistryRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*GetRegistryRequest) Descriptor deprecated 

func (*GetRegistryRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetRegistryRequest.ProtoReflect.Descriptor instead.

func (*GetRegistryRequest) GetName 

func (x *GetRegistryRequest) GetName() string

func (*GetRegistryRequest) ProtoMessage 

func (*GetRegistryRequest) ProtoMessage()

func (*GetRegistryRequest) ProtoReflect 

func (x *GetRegistryRequest) ProtoReflect() protoreflect.Message

func (*GetRegistryRequest) Reset 

func (x *GetRegistryRequest) Reset()

func (*GetRegistryRequest) String 

func (x *GetRegistryRequest) String() string

type GetRegistryResponse 

type GetRegistryResponse struct {
	Registry *RegistryConfig `protobuf:"bytes,1,opt,name=registry,proto3" json:"registry,omitempty"`
	// contains filtered or unexported fields
}

func (*GetRegistryResponse) Descriptor deprecated 

func (*GetRegistryResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetRegistryResponse.ProtoReflect.Descriptor instead.

func (*GetRegistryResponse) GetRegistry 

func (x *GetRegistryResponse) GetRegistry() *RegistryConfig

func (*GetRegistryResponse) ProtoMessage 

func (*GetRegistryResponse) ProtoMessage()

func (*GetRegistryResponse) ProtoReflect 

func (x *GetRegistryResponse) ProtoReflect() protoreflect.Message

func (*GetRegistryResponse) Reset 

func (x *GetRegistryResponse) Reset()

func (*GetRegistryResponse) String 

func (x *GetRegistryResponse) String() string

type GetSecretRequest 

type GetSecretRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSecretRequest) Descriptor deprecated 

func (*GetSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetSecretRequest.ProtoReflect.Descriptor instead.

func (*GetSecretRequest) GetName 

func (x *GetSecretRequest) GetName() string

func (*GetSecretRequest) GetNamespace 

func (x *GetSecretRequest) GetNamespace() string

func (*GetSecretRequest) ProtoMessage 

func (*GetSecretRequest) ProtoMessage()

func (*GetSecretRequest) ProtoReflect 

func (x *GetSecretRequest) ProtoReflect() protoreflect.Message

func (*GetSecretRequest) Reset 

func (x *GetSecretRequest) Reset()

func (*GetSecretRequest) String 

func (x *GetSecretRequest) String() string

type GetServerVersionRequest 

type GetServerVersionRequest struct {
	// contains filtered or unexported fields
}

GetServerVersionRequest requests server build/version information.

func (*GetServerVersionRequest) Descriptor deprecated 

func (*GetServerVersionRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetServerVersionRequest.ProtoReflect.Descriptor instead.

func (*GetServerVersionRequest) ProtoMessage 

func (*GetServerVersionRequest) ProtoMessage()

func (*GetServerVersionRequest) ProtoReflect 

func (x *GetServerVersionRequest) ProtoReflect() protoreflect.Message

func (*GetServerVersionRequest) Reset 

func (x *GetServerVersionRequest) Reset()

func (*GetServerVersionRequest) String 

func (x *GetServerVersionRequest) String() string

type GetServerVersionResponse 

type GetServerVersionResponse struct {

	// Semantic (or dev) version string of the running server binary.
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Git commit SHA the binary was built from.
	Commit string `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	// Build timestamp recorded at link time.
	BuildTime string `protobuf:"bytes,3,opt,name=build_time,json=buildTime,proto3" json:"build_time,omitempty"`
	// Go toolchain version used to build the server.
	GoVersion string `protobuf:"bytes,4,opt,name=go_version,json=goVersion,proto3" json:"go_version,omitempty"`
	// Operating system the server is running on (GOOS).
	Os string `protobuf:"bytes,5,opt,name=os,proto3" json:"os,omitempty"`
	// Architecture the server is running on (GOARCH).
	Arch string `protobuf:"bytes,6,opt,name=arch,proto3" json:"arch,omitempty"`
	// contains filtered or unexported fields
}

GetServerVersionResponse returns server build/version information.

func (*GetServerVersionResponse) Descriptor deprecated 

func (*GetServerVersionResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetServerVersionResponse.ProtoReflect.Descriptor instead.

func (*GetServerVersionResponse) GetArch 

func (x *GetServerVersionResponse) GetArch() string

func (*GetServerVersionResponse) GetBuildTime 

func (x *GetServerVersionResponse) GetBuildTime() string

func (*GetServerVersionResponse) GetCommit 

func (x *GetServerVersionResponse) GetCommit() string

func (*GetServerVersionResponse) GetGoVersion 

func (x *GetServerVersionResponse) GetGoVersion() string

func (*GetServerVersionResponse) GetOs 

func (x *GetServerVersionResponse) GetOs() string

func (*GetServerVersionResponse) GetVersion 

func (x *GetServerVersionResponse) GetVersion() string

func (*GetServerVersionResponse) ProtoMessage 

func (*GetServerVersionResponse) ProtoMessage()

func (*GetServerVersionResponse) ProtoReflect 

func (x *GetServerVersionResponse) ProtoReflect() protoreflect.Message

func (*GetServerVersionResponse) Reset 

func (x *GetServerVersionResponse) Reset()

func (*GetServerVersionResponse) String 

func (x *GetServerVersionResponse) String() string

type GetServiceRequest 

type GetServiceRequest struct {

	// Name of the service
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

GetServiceRequest requests a specific service.

func (*GetServiceRequest) Descriptor deprecated 

func (*GetServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead.

func (*GetServiceRequest) GetName 

func (x *GetServiceRequest) GetName() string

func (*GetServiceRequest) GetNamespace 

func (x *GetServiceRequest) GetNamespace() string

func (*GetServiceRequest) ProtoMessage 

func (*GetServiceRequest) ProtoMessage()

func (*GetServiceRequest) ProtoReflect 

func (x *GetServiceRequest) ProtoReflect() protoreflect.Message

func (*GetServiceRequest) Reset 

func (x *GetServiceRequest) Reset()

func (*GetServiceRequest) String 

func (x *GetServiceRequest) String() string

type GetSnapshotRequest 

type GetSnapshotRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSnapshotRequest) Descriptor deprecated 

func (*GetSnapshotRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetSnapshotRequest.ProtoReflect.Descriptor instead.

func (*GetSnapshotRequest) GetName 

func (x *GetSnapshotRequest) GetName() string

func (*GetSnapshotRequest) GetNamespace 

func (x *GetSnapshotRequest) GetNamespace() string

func (*GetSnapshotRequest) ProtoMessage 

func (*GetSnapshotRequest) ProtoMessage()

func (*GetSnapshotRequest) ProtoReflect 

func (x *GetSnapshotRequest) ProtoReflect() protoreflect.Message

func (*GetSnapshotRequest) Reset 

func (x *GetSnapshotRequest) Reset()

func (*GetSnapshotRequest) String 

func (x *GetSnapshotRequest) String() string

type GetStorageClassRequest 

type GetStorageClassRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*GetStorageClassRequest) Descriptor deprecated 

func (*GetStorageClassRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetStorageClassRequest.ProtoReflect.Descriptor instead.

func (*GetStorageClassRequest) GetName 

func (x *GetStorageClassRequest) GetName() string

func (*GetStorageClassRequest) ProtoMessage 

func (*GetStorageClassRequest) ProtoMessage()

func (*GetStorageClassRequest) ProtoReflect 

func (x *GetStorageClassRequest) ProtoReflect() protoreflect.Message

func (*GetStorageClassRequest) Reset 

func (x *GetStorageClassRequest) Reset()

func (*GetStorageClassRequest) String 

func (x *GetStorageClassRequest) String() string

type GetVolumeRequest 

type GetVolumeRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*GetVolumeRequest) Descriptor deprecated 

func (*GetVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetVolumeRequest) GetName 

func (x *GetVolumeRequest) GetName() string

func (*GetVolumeRequest) GetNamespace 

func (x *GetVolumeRequest) GetNamespace() string

func (*GetVolumeRequest) ProtoMessage 

func (*GetVolumeRequest) ProtoMessage()

func (*GetVolumeRequest) ProtoReflect 

func (x *GetVolumeRequest) ProtoReflect() protoreflect.Message

func (*GetVolumeRequest) Reset 

func (x *GetVolumeRequest) Reset()

func (*GetVolumeRequest) String 

func (x *GetVolumeRequest) String() string

type HealthCheck 

type HealthCheck struct {

	// Liveness probe checks if the instance is running
	Liveness *Probe `protobuf:"bytes,1,opt,name=liveness,proto3" json:"liveness,omitempty"`
	// Readiness probe checks if the instance is ready to receive traffic
	Readiness *Probe `protobuf:"bytes,2,opt,name=readiness,proto3" json:"readiness,omitempty"`
	// contains filtered or unexported fields
}

HealthCheck represents health check configuration for a service.

func (*HealthCheck) Descriptor deprecated 

func (*HealthCheck) Descriptor() ([]byte, []int)

Deprecated: Use HealthCheck.ProtoReflect.Descriptor instead.

func (*HealthCheck) GetLiveness 

func (x *HealthCheck) GetLiveness() *Probe

func (*HealthCheck) GetReadiness 

func (x *HealthCheck) GetReadiness() *Probe

func (*HealthCheck) ProtoMessage 

func (*HealthCheck) ProtoMessage()

func (*HealthCheck) ProtoReflect 

func (x *HealthCheck) ProtoReflect() protoreflect.Message

func (*HealthCheck) Reset 

func (x *HealthCheck) Reset()

func (*HealthCheck) String 

func (x *HealthCheck) String() string

type HealthCheckResult 

type HealthCheckResult struct {

	// Type of health check
	Type HealthCheckType `protobuf:"varint,1,opt,name=type,proto3,enum=rune.api.HealthCheckType" json:"type,omitempty"`
	// Status of the check
	Status HealthStatus `protobuf:"varint,2,opt,name=status,proto3,enum=rune.api.HealthStatus" json:"status,omitempty"`
	// Detailed message about the health status
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	// Last check timestamp (RFC 3339 format)
	Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Consecutive successes
	ConsecutiveSuccesses int32 `protobuf:"varint,5,opt,name=consecutive_successes,json=consecutiveSuccesses,proto3" json:"consecutive_successes,omitempty"`
	// Consecutive failures
	ConsecutiveFailures int32 `protobuf:"varint,6,opt,name=consecutive_failures,json=consecutiveFailures,proto3" json:"consecutive_failures,omitempty"`
	// contains filtered or unexported fields
}

HealthCheckResult represents the result of a health check.

func (*HealthCheckResult) Descriptor deprecated 

func (*HealthCheckResult) Descriptor() ([]byte, []int)

Deprecated: Use HealthCheckResult.ProtoReflect.Descriptor instead.

func (*HealthCheckResult) GetConsecutiveFailures 

func (x *HealthCheckResult) GetConsecutiveFailures() int32

func (*HealthCheckResult) GetConsecutiveSuccesses 

func (x *HealthCheckResult) GetConsecutiveSuccesses() int32

func (*HealthCheckResult) GetMessage 

func (x *HealthCheckResult) GetMessage() string

func (*HealthCheckResult) GetStatus 

func (x *HealthCheckResult) GetStatus() HealthStatus

func (*HealthCheckResult) GetTimestamp 

func (x *HealthCheckResult) GetTimestamp() string

func (*HealthCheckResult) GetType 

func (x *HealthCheckResult) GetType() HealthCheckType

func (*HealthCheckResult) ProtoMessage 

func (*HealthCheckResult) ProtoMessage()

func (*HealthCheckResult) ProtoReflect 

func (x *HealthCheckResult) ProtoReflect() protoreflect.Message

func (*HealthCheckResult) Reset 

func (x *HealthCheckResult) Reset()

func (*HealthCheckResult) String 

func (x *HealthCheckResult) String() string

type HealthCheckType 

type HealthCheckType int32

HealthCheckType defines different types of health checks. 

const (
	HealthCheckType_HEALTH_CHECK_TYPE_UNSPECIFIED HealthCheckType = 0
	HealthCheckType_HEALTH_CHECK_TYPE_LIVENESS    HealthCheckType = 1 // Basic liveness check
	HealthCheckType_HEALTH_CHECK_TYPE_READINESS   HealthCheckType = 2 // Readiness to receive traffic
	HealthCheckType_HEALTH_CHECK_TYPE_STARTUP     HealthCheckType = 3 // Initialization check
)

func (HealthCheckType) Descriptor 

func (HealthCheckType) Descriptor() protoreflect.EnumDescriptor

func (HealthCheckType) Enum 

func (x HealthCheckType) Enum() *HealthCheckType

func (HealthCheckType) EnumDescriptor deprecated 

func (HealthCheckType) EnumDescriptor() ([]byte, []int)

Deprecated: Use HealthCheckType.Descriptor instead.

func (HealthCheckType) Number 

func (x HealthCheckType) Number() protoreflect.EnumNumber

func (HealthCheckType) String 

func (x HealthCheckType) String() string

func (HealthCheckType) Type 

func (HealthCheckType) Type() protoreflect.EnumType

type HealthServiceClient 

type HealthServiceClient interface {
	// GetHealth retrieves health status of platform components.
	GetHealth(ctx context.Context, in *GetHealthRequest, opts ...grpc.CallOption) (*GetHealthResponse, error)
	// GetServerVersion returns build/version information for the running
	// server binary. Intentionally unauthenticated so `rune version` can
	// report it before the user has logged in.
	GetServerVersion(ctx context.Context, in *GetServerVersionRequest, opts ...grpc.CallOption) (*GetServerVersionResponse, error)
}

HealthServiceClient is the client API for HealthService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

HealthService provides health status information about platform components.

func NewHealthServiceClient 

func NewHealthServiceClient(cc grpc.ClientConnInterface) HealthServiceClient

type HealthServiceServer 

type HealthServiceServer interface {
	// GetHealth retrieves health status of platform components.
	GetHealth(context.Context, *GetHealthRequest) (*GetHealthResponse, error)
	// GetServerVersion returns build/version information for the running
	// server binary. Intentionally unauthenticated so `rune version` can
	// report it before the user has logged in.
	GetServerVersion(context.Context, *GetServerVersionRequest) (*GetServerVersionResponse, error)
	// contains filtered or unexported methods
}

HealthServiceServer is the server API for HealthService service. All implementations must embed UnimplementedHealthServiceServer for forward compatibility.

HealthService provides health status information about platform components.

type HealthStatus 

type HealthStatus int32

HealthStatus represents the health status of a component. 

const (
	HealthStatus_HEALTH_STATUS_UNSPECIFIED HealthStatus = 0
	HealthStatus_HEALTH_STATUS_UNKNOWN     HealthStatus = 1 // Status is unknown
	HealthStatus_HEALTH_STATUS_HEALTHY     HealthStatus = 2 // Healthy and functioning correctly
	HealthStatus_HEALTH_STATUS_UNHEALTHY   HealthStatus = 3 // Unhealthy and not functioning correctly
	HealthStatus_HEALTH_STATUS_DEGRADED    HealthStatus = 4 // Functioning but with reduced capabilities
)

func (HealthStatus) Descriptor 

func (HealthStatus) Descriptor() protoreflect.EnumDescriptor

func (HealthStatus) Enum 

func (x HealthStatus) Enum() *HealthStatus

func (HealthStatus) EnumDescriptor deprecated 

func (HealthStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use HealthStatus.Descriptor instead.

func (HealthStatus) Number 

func (x HealthStatus) Number() protoreflect.EnumNumber

func (HealthStatus) String 

func (x HealthStatus) String() string

func (HealthStatus) Type 

func (HealthStatus) Type() protoreflect.EnumType

type InitStep 

type InitStep struct {

	// DNS-1123 identifier, unique within the service's init_steps.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Container image. Required when the parent service runtime is
	// "container". Empty for runtime="process".
	Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	// Command to run. No entrypoint inheritance from the parent image.
	Command string `protobuf:"bytes,3,opt,name=command,proto3" json:"command,omitempty"`
	// Positional arguments to command.
	Args []string `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
	// Env merged on top of the parent service's env. Step keys win.
	Env map[string]string `` /* 133-byte string literal not displayed */
	// EnvFrom merged with the parent's EnvFrom.
	EnvFrom []*EnvFromSource `protobuf:"bytes,6,rep,name=env_from,json=envFrom,proto3" json:"env_from,omitempty"`
	// Volumes filter: unset = inherit all, [] = none, [a,b] = a and b.
	// volumes_set distinguishes "not set" from "empty" on the wire.
	Volumes    []string `protobuf:"bytes,7,rep,name=volumes,proto3" json:"volumes,omitempty"`
	VolumesSet bool     `protobuf:"varint,8,opt,name=volumes_set,json=volumesSet,proto3" json:"volumes_set,omitempty"`
	// Secret mount filter, same convention as volumes.
	SecretMounts    []string `protobuf:"bytes,9,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"`
	SecretMountsSet bool     `protobuf:"varint,10,opt,name=secret_mounts_set,json=secretMountsSet,proto3" json:"secret_mounts_set,omitempty"`
	// Configmap mount filter, same convention as volumes.
	ConfigmapMounts    []string `protobuf:"bytes,11,rep,name=configmap_mounts,json=configmapMounts,proto3" json:"configmap_mounts,omitempty"`
	ConfigmapMountsSet bool     `protobuf:"varint,12,opt,name=configmap_mounts_set,json=configmapMountsSet,proto3" json:"configmap_mounts_set,omitempty"`
	// Optional resource override for this step.
	Resources *Resources `protobuf:"bytes,13,opt,name=resources,proto3" json:"resources,omitempty"`
	// Predicate selecting when this step runs.
	RunIf *RunIfSpec `protobuf:"bytes,14,opt,name=run_if,json=runIf,proto3" json:"run_if,omitempty"`
	// Per-step timeout in nanoseconds (matches Go time.Duration).
	// 0 defers to the cast-level timeout.
	TimeoutNanos int64 `protobuf:"varint,15,opt,name=timeout_nanos,json=timeoutNanos,proto3" json:"timeout_nanos,omitempty"`
	// Restart policy: "OnFailure" (default) | "Never".
	RestartPolicy string `protobuf:"bytes,16,opt,name=restart_policy,json=restartPolicy,proto3" json:"restart_policy,omitempty"`
	// Optional security context applied to this init container.
	SecurityContext *SecurityContext `protobuf:"bytes,17,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"`
	// contains filtered or unexported fields
}

InitStep is a one-shot container/process executed before the main container of a Service starts. Mirrors types.InitStep (RUNE-121).

func (*InitStep) Descriptor deprecated 

func (*InitStep) Descriptor() ([]byte, []int)

Deprecated: Use InitStep.ProtoReflect.Descriptor instead.

func (*InitStep) GetArgs 

func (x *InitStep) GetArgs() []string

func (*InitStep) GetCommand 

func (x *InitStep) GetCommand() string

func (*InitStep) GetConfigmapMounts 

func (x *InitStep) GetConfigmapMounts() []string

func (*InitStep) GetConfigmapMountsSet 

func (x *InitStep) GetConfigmapMountsSet() bool

func (*InitStep) GetEnv 

func (x *InitStep) GetEnv() map[string]string

func (*InitStep) GetEnvFrom 

func (x *InitStep) GetEnvFrom() []*EnvFromSource

func (*InitStep) GetImage 

func (x *InitStep) GetImage() string

func (*InitStep) GetName 

func (x *InitStep) GetName() string

func (*InitStep) GetResources 

func (x *InitStep) GetResources() *Resources

func (*InitStep) GetRestartPolicy 

func (x *InitStep) GetRestartPolicy() string

func (*InitStep) GetRunIf 

func (x *InitStep) GetRunIf() *RunIfSpec

func (*InitStep) GetSecretMounts 

func (x *InitStep) GetSecretMounts() []string

func (*InitStep) GetSecretMountsSet 

func (x *InitStep) GetSecretMountsSet() bool

func (*InitStep) GetSecurityContext 

func (x *InitStep) GetSecurityContext() *SecurityContext

func (*InitStep) GetTimeoutNanos 

func (x *InitStep) GetTimeoutNanos() int64

func (*InitStep) GetVolumes 

func (x *InitStep) GetVolumes() []string

func (*InitStep) GetVolumesSet 

func (x *InitStep) GetVolumesSet() bool

func (*InitStep) ProtoMessage 

func (*InitStep) ProtoMessage()

func (*InitStep) ProtoReflect 

func (x *InitStep) ProtoReflect() protoreflect.Message

func (*InitStep) Reset 

func (x *InitStep) Reset()

func (*InitStep) String 

func (x *InitStep) String() string

type Instance 

type Instance struct {

	// Unique identifier for the instance
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Runner type for the instance
	Runner string `protobuf:"bytes,2,opt,name=runner,proto3" json:"runner,omitempty"`
	// Namespace of the instance
	Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Human-readable name for the instance
	Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	// ID of the service this instance belongs to
	ServiceId string `protobuf:"bytes,5,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	// Name of the service this instance belongs to
	ServiceName string `protobuf:"bytes,6,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// ID of the node running this instance
	NodeId string `protobuf:"bytes,7,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// IP address assigned to this instance
	Ip string `protobuf:"bytes,8,opt,name=ip,proto3" json:"ip,omitempty"`
	// Status of the instance
	Status InstanceStatus `protobuf:"varint,9,opt,name=status,proto3,enum=rune.api.InstanceStatus" json:"status,omitempty"`
	// Detailed status information
	StatusMessage string `protobuf:"bytes,10,opt,name=status_message,json=statusMessage,proto3" json:"status_message,omitempty"`
	// Container ID or process ID
	ContainerId string `protobuf:"bytes,11,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
	// Process ID for process runner
	Pid int32 `protobuf:"varint,12,opt,name=pid,proto3" json:"pid,omitempty"`
	// Creation timestamp (in RFC 3339 format)
	CreatedAt string `protobuf:"bytes,13,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp (in RFC 3339 format)
	UpdatedAt string `protobuf:"bytes,14,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Resource usage
	Resources *Resources `protobuf:"bytes,15,opt,name=resources,proto3" json:"resources,omitempty"`
	// Environment variables
	Environment map[string]string `` /* 150-byte string literal not displayed */
	// Metadata
	Metadata *InstanceMetadata `protobuf:"bytes,17,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

Instance represents a running copy of a service.

func (*Instance) Descriptor deprecated 

func (*Instance) Descriptor() ([]byte, []int)

Deprecated: Use Instance.ProtoReflect.Descriptor instead.

func (*Instance) GetContainerId 

func (x *Instance) GetContainerId() string

func (*Instance) GetCreatedAt 

func (x *Instance) GetCreatedAt() string

func (*Instance) GetEnvironment 

func (x *Instance) GetEnvironment() map[string]string

func (*Instance) GetId 

func (x *Instance) GetId() string

func (*Instance) GetIp 

func (x *Instance) GetIp() string

func (*Instance) GetMetadata 

func (x *Instance) GetMetadata() *InstanceMetadata

func (*Instance) GetName 

func (x *Instance) GetName() string

func (*Instance) GetNamespace 

func (x *Instance) GetNamespace() string

func (*Instance) GetNodeId 

func (x *Instance) GetNodeId() string

func (*Instance) GetPid 

func (x *Instance) GetPid() int32

func (*Instance) GetResources 

func (x *Instance) GetResources() *Resources

func (*Instance) GetRunner 

func (x *Instance) GetRunner() string

func (*Instance) GetServiceId 

func (x *Instance) GetServiceId() string

func (*Instance) GetServiceName 

func (x *Instance) GetServiceName() string

func (*Instance) GetStatus 

func (x *Instance) GetStatus() InstanceStatus

func (*Instance) GetStatusMessage 

func (x *Instance) GetStatusMessage() string

func (*Instance) GetUpdatedAt 

func (x *Instance) GetUpdatedAt() string

func (*Instance) ProtoMessage 

func (*Instance) ProtoMessage()

func (*Instance) ProtoReflect 

func (x *Instance) ProtoReflect() protoreflect.Message

func (*Instance) Reset 

func (x *Instance) Reset()

func (*Instance) String 

func (x *Instance) String() string

type InstanceActionRequest 

type InstanceActionRequest struct {

	// ID of the instance
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Timeout in seconds for the action
	TimeoutSeconds int32 `protobuf:"varint,2,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	// Force the action if applicable
	Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// contains filtered or unexported fields
}

InstanceActionRequest requests an action on an instance.

func (*InstanceActionRequest) Descriptor deprecated 

func (*InstanceActionRequest) Descriptor() ([]byte, []int)

Deprecated: Use InstanceActionRequest.ProtoReflect.Descriptor instead.

func (*InstanceActionRequest) GetForce 

func (x *InstanceActionRequest) GetForce() bool

func (*InstanceActionRequest) GetId 

func (x *InstanceActionRequest) GetId() string

func (*InstanceActionRequest) GetTimeoutSeconds 

func (x *InstanceActionRequest) GetTimeoutSeconds() int32

func (*InstanceActionRequest) ProtoMessage 

func (*InstanceActionRequest) ProtoMessage()

func (*InstanceActionRequest) ProtoReflect 

func (x *InstanceActionRequest) ProtoReflect() protoreflect.Message

func (*InstanceActionRequest) Reset 

func (x *InstanceActionRequest) Reset()

func (*InstanceActionRequest) String 

func (x *InstanceActionRequest) String() string

type InstanceMetadata 

type InstanceMetadata struct {

	// Generation number for the service
	Generation int32 `protobuf:"varint,1,opt,name=generation,proto3" json:"generation,omitempty"`
	// Deletion timestamp
	DeletionTimestamp string `protobuf:"bytes,2,opt,name=deletion_timestamp,json=deletionTimestamp,proto3" json:"deletion_timestamp,omitempty"`
	// Number of times the instance has been restarted
	RestartCount int32 `protobuf:"varint,3,opt,name=restart_count,json=restartCount,proto3" json:"restart_count,omitempty"`
	// Secret mounts with resolved data
	SecretMounts []*ResolvedSecretMount `protobuf:"bytes,4,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"`
	// Config mounts with resolved data
	ConfigMounts []*ResolvedConfigMount `protobuf:"bytes,5,rep,name=config_mounts,json=configMounts,proto3" json:"config_mounts,omitempty"`
	// contains filtered or unexported fields
}

InstanceMetadata represents metadata for an instance.

func (*InstanceMetadata) Descriptor deprecated 

func (*InstanceMetadata) Descriptor() ([]byte, []int)

Deprecated: Use InstanceMetadata.ProtoReflect.Descriptor instead.

func (*InstanceMetadata) GetConfigMounts 

func (x *InstanceMetadata) GetConfigMounts() []*ResolvedConfigMount

func (*InstanceMetadata) GetDeletionTimestamp 

func (x *InstanceMetadata) GetDeletionTimestamp() string

func (*InstanceMetadata) GetGeneration 

func (x *InstanceMetadata) GetGeneration() int32

func (*InstanceMetadata) GetRestartCount 

func (x *InstanceMetadata) GetRestartCount() int32

func (*InstanceMetadata) GetSecretMounts 

func (x *InstanceMetadata) GetSecretMounts() []*ResolvedSecretMount

func (*InstanceMetadata) ProtoMessage 

func (*InstanceMetadata) ProtoMessage()

func (*InstanceMetadata) ProtoReflect 

func (x *InstanceMetadata) ProtoReflect() protoreflect.Message

func (*InstanceMetadata) Reset 

func (x *InstanceMetadata) Reset()

func (*InstanceMetadata) String 

func (x *InstanceMetadata) String() string

type InstanceResponse 

type InstanceResponse struct {

	// The instance, if successful
	Instance *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

InstanceResponse returns an instance or status.

func (*InstanceResponse) Descriptor deprecated 

func (*InstanceResponse) Descriptor() ([]byte, []int)

Deprecated: Use InstanceResponse.ProtoReflect.Descriptor instead.

func (*InstanceResponse) GetInstance 

func (x *InstanceResponse) GetInstance() *Instance

func (*InstanceResponse) GetStatus 

func (x *InstanceResponse) GetStatus() *Status

func (*InstanceResponse) ProtoMessage 

func (*InstanceResponse) ProtoMessage()

func (*InstanceResponse) ProtoReflect 

func (x *InstanceResponse) ProtoReflect() protoreflect.Message

func (*InstanceResponse) Reset 

func (x *InstanceResponse) Reset()

func (*InstanceResponse) String 

func (x *InstanceResponse) String() string

type InstanceServiceClient 

type InstanceServiceClient interface {
	// GetInstance retrieves an instance by ID.
	GetInstance(ctx context.Context, in *GetInstanceRequest, opts ...grpc.CallOption) (*InstanceResponse, error)
	// ListInstances lists instances with filtering.
	ListInstances(ctx context.Context, in *ListInstancesRequest, opts ...grpc.CallOption) (*ListInstancesResponse, error)
	// StartInstance starts an instance.
	StartInstance(ctx context.Context, in *InstanceActionRequest, opts ...grpc.CallOption) (*InstanceResponse, error)
	// StopInstance stops an instance.
	StopInstance(ctx context.Context, in *InstanceActionRequest, opts ...grpc.CallOption) (*InstanceResponse, error)
	// RestartInstance restarts an instance.
	RestartInstance(ctx context.Context, in *InstanceActionRequest, opts ...grpc.CallOption) (*InstanceResponse, error)
	// WatchInstances watches instances for changes.
	WatchInstances(ctx context.Context, in *WatchInstancesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchInstancesResponse], error)
}

InstanceServiceClient is the client API for InstanceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

InstanceService manages service instances within the platform.

func NewInstanceServiceClient 

func NewInstanceServiceClient(cc grpc.ClientConnInterface) InstanceServiceClient

type InstanceServiceServer 

type InstanceServiceServer interface {
	// GetInstance retrieves an instance by ID.
	GetInstance(context.Context, *GetInstanceRequest) (*InstanceResponse, error)
	// ListInstances lists instances with filtering.
	ListInstances(context.Context, *ListInstancesRequest) (*ListInstancesResponse, error)
	// StartInstance starts an instance.
	StartInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)
	// StopInstance stops an instance.
	StopInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)
	// RestartInstance restarts an instance.
	RestartInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)
	// WatchInstances watches instances for changes.
	WatchInstances(*WatchInstancesRequest, grpc.ServerStreamingServer[WatchInstancesResponse]) error
	// contains filtered or unexported methods
}

InstanceServiceServer is the server API for InstanceService service. All implementations must embed UnimplementedInstanceServiceServer for forward compatibility.

InstanceService manages service instances within the platform.

type InstanceService_WatchInstancesClient 

type InstanceService_WatchInstancesClient = grpc.ServerStreamingClient[WatchInstancesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type InstanceService_WatchInstancesServer 

type InstanceService_WatchInstancesServer = grpc.ServerStreamingServer[WatchInstancesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type InstanceStatus 

type InstanceStatus int32

InstanceStatus represents the current status of an instance. 

const (
	InstanceStatus_INSTANCE_STATUS_UNSPECIFIED InstanceStatus = 0
	InstanceStatus_INSTANCE_STATUS_PENDING     InstanceStatus = 1 // Instance is being created
	InstanceStatus_INSTANCE_STATUS_CREATED     InstanceStatus = 2 // Instance is created but not started
	InstanceStatus_INSTANCE_STATUS_STARTING    InstanceStatus = 3 // Instance is starting
	InstanceStatus_INSTANCE_STATUS_RUNNING     InstanceStatus = 4 // Instance is running
	InstanceStatus_INSTANCE_STATUS_STOPPING    InstanceStatus = 5 // Instance is stopping
	InstanceStatus_INSTANCE_STATUS_STOPPED     InstanceStatus = 6 // Instance has stopped
	InstanceStatus_INSTANCE_STATUS_FAILED      InstanceStatus = 7 // Instance failed to start or crashed
	InstanceStatus_INSTANCE_STATUS_EXITED      InstanceStatus = 8 // Instance exited
	InstanceStatus_INSTANCE_STATUS_DELETED     InstanceStatus = 9 // Instance is deleted
)

func (InstanceStatus) Descriptor 

func (InstanceStatus) Descriptor() protoreflect.EnumDescriptor

func (InstanceStatus) Enum 

func (x InstanceStatus) Enum() *InstanceStatus

func (InstanceStatus) EnumDescriptor deprecated 

func (InstanceStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use InstanceStatus.Descriptor instead.

func (InstanceStatus) Number 

func (x InstanceStatus) Number() protoreflect.EnumNumber

func (InstanceStatus) String 

func (x InstanceStatus) String() string

func (InstanceStatus) Type 

func (InstanceStatus) Type() protoreflect.EnumType

type KeyToPath 

type KeyToPath struct {

	// Key in the Secret or Config
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Path where the key should be mounted (relative to mount point)
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

KeyToPath defines mapping from a key in a Secret/Config to a path in the mount

func (*KeyToPath) Descriptor deprecated 

func (*KeyToPath) Descriptor() ([]byte, []int)

Deprecated: Use KeyToPath.ProtoReflect.Descriptor instead.

func (*KeyToPath) GetKey 

func (x *KeyToPath) GetKey() string

func (*KeyToPath) GetPath 

func (x *KeyToPath) GetPath() string

func (*KeyToPath) ProtoMessage 

func (*KeyToPath) ProtoMessage()

func (*KeyToPath) ProtoReflect 

func (x *KeyToPath) ProtoReflect() protoreflect.Message

func (*KeyToPath) Reset 

func (x *KeyToPath) Reset()

func (*KeyToPath) String 

func (x *KeyToPath) String() string

type ListAuditEventsRequest 

type ListAuditEventsRequest struct {
	Resource    string `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
	ResourceRef string `protobuf:"bytes,2,opt,name=resource_ref,json=resourceRef,proto3" json:"resource_ref,omitempty"`
	Namespace   string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Actor       string `protobuf:"bytes,4,opt,name=actor,proto3" json:"actor,omitempty"`
	Action      string `protobuf:"bytes,5,opt,name=action,proto3" json:"action,omitempty"`
	Since       string `protobuf:"bytes,6,opt,name=since,proto3" json:"since,omitempty"` // RFC3339; events at or after this timestamp
	Until       string `protobuf:"bytes,7,opt,name=until,proto3" json:"until,omitempty"` // RFC3339; events strictly before this timestamp
	Limit       int32  `protobuf:"varint,8,opt,name=limit,proto3" json:"limit,omitempty"`
	// contains filtered or unexported fields
}

ListAuditEventsRequest narrows the audit log by exact-match filters and a time window. All fields are optional. A limit of 0 applies a server-side default cap (200).

func (*ListAuditEventsRequest) Descriptor deprecated 

func (*ListAuditEventsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListAuditEventsRequest.ProtoReflect.Descriptor instead.

func (*ListAuditEventsRequest) GetAction 

func (x *ListAuditEventsRequest) GetAction() string

func (*ListAuditEventsRequest) GetActor 

func (x *ListAuditEventsRequest) GetActor() string

func (*ListAuditEventsRequest) GetLimit 

func (x *ListAuditEventsRequest) GetLimit() int32

func (*ListAuditEventsRequest) GetNamespace 

func (x *ListAuditEventsRequest) GetNamespace() string

func (*ListAuditEventsRequest) GetResource 

func (x *ListAuditEventsRequest) GetResource() string

func (*ListAuditEventsRequest) GetResourceRef 

func (x *ListAuditEventsRequest) GetResourceRef() string

func (*ListAuditEventsRequest) GetSince 

func (x *ListAuditEventsRequest) GetSince() string

func (*ListAuditEventsRequest) GetUntil 

func (x *ListAuditEventsRequest) GetUntil() string

func (*ListAuditEventsRequest) ProtoMessage 

func (*ListAuditEventsRequest) ProtoMessage()

func (*ListAuditEventsRequest) ProtoReflect 

func (x *ListAuditEventsRequest) ProtoReflect() protoreflect.Message

func (*ListAuditEventsRequest) Reset 

func (x *ListAuditEventsRequest) Reset()

func (*ListAuditEventsRequest) String 

func (x *ListAuditEventsRequest) String() string

type ListAuditEventsResponse 

type ListAuditEventsResponse struct {
	Events []*AuditEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	Status *Status       `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListAuditEventsResponse) Descriptor deprecated 

func (*ListAuditEventsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListAuditEventsResponse.ProtoReflect.Descriptor instead.

func (*ListAuditEventsResponse) GetEvents 

func (x *ListAuditEventsResponse) GetEvents() []*AuditEvent

func (*ListAuditEventsResponse) GetStatus 

func (x *ListAuditEventsResponse) GetStatus() *Status

func (*ListAuditEventsResponse) ProtoMessage 

func (*ListAuditEventsResponse) ProtoMessage()

func (*ListAuditEventsResponse) ProtoReflect 

func (x *ListAuditEventsResponse) ProtoReflect() protoreflect.Message

func (*ListAuditEventsResponse) Reset 

func (x *ListAuditEventsResponse) Reset()

func (*ListAuditEventsResponse) String 

func (x *ListAuditEventsResponse) String() string

type ListConfigmapsRequest 

type ListConfigmapsRequest struct {
	Namespace     string            `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	Paging        *PagingParams     `protobuf:"bytes,4,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

func (*ListConfigmapsRequest) Descriptor deprecated 

func (*ListConfigmapsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListConfigmapsRequest.ProtoReflect.Descriptor instead.

func (*ListConfigmapsRequest) GetFieldSelector 

func (x *ListConfigmapsRequest) GetFieldSelector() map[string]string

func (*ListConfigmapsRequest) GetLabelSelector 

func (x *ListConfigmapsRequest) GetLabelSelector() map[string]string

func (*ListConfigmapsRequest) GetNamespace 

func (x *ListConfigmapsRequest) GetNamespace() string

func (*ListConfigmapsRequest) GetPaging 

func (x *ListConfigmapsRequest) GetPaging() *PagingParams

func (*ListConfigmapsRequest) ProtoMessage 

func (*ListConfigmapsRequest) ProtoMessage()

func (*ListConfigmapsRequest) ProtoReflect 

func (x *ListConfigmapsRequest) ProtoReflect() protoreflect.Message

func (*ListConfigmapsRequest) Reset 

func (x *ListConfigmapsRequest) Reset()

func (*ListConfigmapsRequest) String 

func (x *ListConfigmapsRequest) String() string

type ListConfigmapsResponse 

type ListConfigmapsResponse struct {
	Configmaps []*Configmap `protobuf:"bytes,1,rep,name=configmaps,proto3" json:"configmaps,omitempty"`
	Status     *Status      `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListConfigmapsResponse) Descriptor deprecated 

func (*ListConfigmapsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListConfigmapsResponse.ProtoReflect.Descriptor instead.

func (*ListConfigmapsResponse) GetConfigmaps 

func (x *ListConfigmapsResponse) GetConfigmaps() []*Configmap

func (*ListConfigmapsResponse) GetStatus 

func (x *ListConfigmapsResponse) GetStatus() *Status

func (*ListConfigmapsResponse) ProtoMessage 

func (*ListConfigmapsResponse) ProtoMessage()

func (*ListConfigmapsResponse) ProtoReflect 

func (x *ListConfigmapsResponse) ProtoReflect() protoreflect.Message

func (*ListConfigmapsResponse) Reset 

func (x *ListConfigmapsResponse) Reset()

func (*ListConfigmapsResponse) String 

func (x *ListConfigmapsResponse) String() string

type ListDeletionOperationsRequest 

type ListDeletionOperationsRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Status    string `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

ListDeletionOperationsRequest represents a request to list deletion operations

func (*ListDeletionOperationsRequest) Descriptor deprecated 

func (*ListDeletionOperationsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListDeletionOperationsRequest.ProtoReflect.Descriptor instead.

func (*ListDeletionOperationsRequest) GetNamespace 

func (x *ListDeletionOperationsRequest) GetNamespace() string

func (*ListDeletionOperationsRequest) GetStatus 

func (x *ListDeletionOperationsRequest) GetStatus() string

func (*ListDeletionOperationsRequest) ProtoMessage 

func (*ListDeletionOperationsRequest) ProtoMessage()

func (*ListDeletionOperationsRequest) ProtoReflect 

func (x *ListDeletionOperationsRequest) ProtoReflect() protoreflect.Message

func (*ListDeletionOperationsRequest) Reset 

func (x *ListDeletionOperationsRequest) Reset()

func (*ListDeletionOperationsRequest) String 

func (x *ListDeletionOperationsRequest) String() string

type ListDeletionOperationsResponse 

type ListDeletionOperationsResponse struct {
	Operations []*DeletionOperation `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
	// contains filtered or unexported fields
}

ListDeletionOperationsResponse represents the response from listing deletion operations

func (*ListDeletionOperationsResponse) Descriptor deprecated 

func (*ListDeletionOperationsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListDeletionOperationsResponse.ProtoReflect.Descriptor instead.

func (*ListDeletionOperationsResponse) GetOperations 

func (x *ListDeletionOperationsResponse) GetOperations() []*DeletionOperation

func (*ListDeletionOperationsResponse) ProtoMessage 

func (*ListDeletionOperationsResponse) ProtoMessage()

func (*ListDeletionOperationsResponse) ProtoReflect 

func (x *ListDeletionOperationsResponse) ProtoReflect() protoreflect.Message

func (*ListDeletionOperationsResponse) Reset 

func (x *ListDeletionOperationsResponse) Reset()

func (*ListDeletionOperationsResponse) String 

func (x *ListDeletionOperationsResponse) String() string

type ListInstancesRequest 

type ListInstancesRequest struct {

	// Filter by service name
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// Filter by namespace
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Filter by node ID
	NodeId string `protobuf:"bytes,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// Filter by status
	Status InstanceStatus `protobuf:"varint,4,opt,name=status,proto3,enum=rune.api.InstanceStatus" json:"status,omitempty"`
	// Paging parameters
	Paging *PagingParams `protobuf:"bytes,5,opt,name=paging,proto3" json:"paging,omitempty"`
	// Filter instances by label
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Filter instances by field
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

ListInstancesRequest requests a list of instances.

func (*ListInstancesRequest) Descriptor deprecated 

func (*ListInstancesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListInstancesRequest.ProtoReflect.Descriptor instead.

func (*ListInstancesRequest) GetFieldSelector 

func (x *ListInstancesRequest) GetFieldSelector() map[string]string

func (*ListInstancesRequest) GetLabelSelector 

func (x *ListInstancesRequest) GetLabelSelector() map[string]string

func (*ListInstancesRequest) GetNamespace 

func (x *ListInstancesRequest) GetNamespace() string

func (*ListInstancesRequest) GetNodeId 

func (x *ListInstancesRequest) GetNodeId() string

func (*ListInstancesRequest) GetPaging 

func (x *ListInstancesRequest) GetPaging() *PagingParams

func (*ListInstancesRequest) GetServiceName 

func (x *ListInstancesRequest) GetServiceName() string

func (*ListInstancesRequest) GetStatus 

func (x *ListInstancesRequest) GetStatus() InstanceStatus

func (*ListInstancesRequest) ProtoMessage 

func (*ListInstancesRequest) ProtoMessage()

func (*ListInstancesRequest) ProtoReflect 

func (x *ListInstancesRequest) ProtoReflect() protoreflect.Message

func (*ListInstancesRequest) Reset 

func (x *ListInstancesRequest) Reset()

func (*ListInstancesRequest) String 

func (x *ListInstancesRequest) String() string

type ListInstancesResponse 

type ListInstancesResponse struct {

	// List of instances
	Instances []*Instance `protobuf:"bytes,1,rep,name=instances,proto3" json:"instances,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// Paging information for continuation
	Paging *PagingParams `protobuf:"bytes,3,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

ListInstancesResponse returns a list of instances.

func (*ListInstancesResponse) Descriptor deprecated 

func (*ListInstancesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListInstancesResponse.ProtoReflect.Descriptor instead.

func (*ListInstancesResponse) GetInstances 

func (x *ListInstancesResponse) GetInstances() []*Instance

func (*ListInstancesResponse) GetPaging 

func (x *ListInstancesResponse) GetPaging() *PagingParams

func (*ListInstancesResponse) GetStatus 

func (x *ListInstancesResponse) GetStatus() *Status

func (*ListInstancesResponse) ProtoMessage 

func (*ListInstancesResponse) ProtoMessage()

func (*ListInstancesResponse) ProtoReflect 

func (x *ListInstancesResponse) ProtoReflect() protoreflect.Message

func (*ListInstancesResponse) Reset 

func (x *ListInstancesResponse) Reset()

func (*ListInstancesResponse) String 

func (x *ListInstancesResponse) String() string

type ListNamespacesRequest 

type ListNamespacesRequest struct {

	// Optional label selector for filtering namespaces
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Optional field selector for filtering namespaces
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

ListNamespacesRequest is the request for listing namespaces.

func (*ListNamespacesRequest) Descriptor deprecated 

func (*ListNamespacesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListNamespacesRequest.ProtoReflect.Descriptor instead.

func (*ListNamespacesRequest) GetFieldSelector 

func (x *ListNamespacesRequest) GetFieldSelector() map[string]string

func (*ListNamespacesRequest) GetLabelSelector 

func (x *ListNamespacesRequest) GetLabelSelector() map[string]string

func (*ListNamespacesRequest) ProtoMessage 

func (*ListNamespacesRequest) ProtoMessage()

func (*ListNamespacesRequest) ProtoReflect 

func (x *ListNamespacesRequest) ProtoReflect() protoreflect.Message

func (*ListNamespacesRequest) Reset 

func (x *ListNamespacesRequest) Reset()

func (*ListNamespacesRequest) String 

func (x *ListNamespacesRequest) String() string

type ListNamespacesResponse 

type ListNamespacesResponse struct {

	// The list of namespaces
	Namespaces []*Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"`
	// Status information
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// Paging information
	Paging *PagingParams `protobuf:"bytes,3,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

ListNamespacesResponse is the response for listing namespaces.

func (*ListNamespacesResponse) Descriptor deprecated 

func (*ListNamespacesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListNamespacesResponse.ProtoReflect.Descriptor instead.

func (*ListNamespacesResponse) GetNamespaces 

func (x *ListNamespacesResponse) GetNamespaces() []*Namespace

func (*ListNamespacesResponse) GetPaging 

func (x *ListNamespacesResponse) GetPaging() *PagingParams

func (*ListNamespacesResponse) GetStatus 

func (x *ListNamespacesResponse) GetStatus() *Status

func (*ListNamespacesResponse) ProtoMessage 

func (*ListNamespacesResponse) ProtoMessage()

func (*ListNamespacesResponse) ProtoReflect 

func (x *ListNamespacesResponse) ProtoReflect() protoreflect.Message

func (*ListNamespacesResponse) Reset 

func (x *ListNamespacesResponse) Reset()

func (*ListNamespacesResponse) String 

func (x *ListNamespacesResponse) String() string

type ListRegistriesRequest 

type ListRegistriesRequest struct {
	// contains filtered or unexported fields
}

func (*ListRegistriesRequest) Descriptor deprecated 

func (*ListRegistriesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListRegistriesRequest.ProtoReflect.Descriptor instead.

func (*ListRegistriesRequest) ProtoMessage 

func (*ListRegistriesRequest) ProtoMessage()

func (*ListRegistriesRequest) ProtoReflect 

func (x *ListRegistriesRequest) ProtoReflect() protoreflect.Message

func (*ListRegistriesRequest) Reset 

func (x *ListRegistriesRequest) Reset()

func (*ListRegistriesRequest) String 

func (x *ListRegistriesRequest) String() string

type ListRegistriesResponse 

type ListRegistriesResponse struct {
	Registries []*RegistryConfig `protobuf:"bytes,1,rep,name=registries,proto3" json:"registries,omitempty"`
	// contains filtered or unexported fields
}

func (*ListRegistriesResponse) Descriptor deprecated 

func (*ListRegistriesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListRegistriesResponse.ProtoReflect.Descriptor instead.

func (*ListRegistriesResponse) GetRegistries 

func (x *ListRegistriesResponse) GetRegistries() []*RegistryConfig

func (*ListRegistriesResponse) ProtoMessage 

func (*ListRegistriesResponse) ProtoMessage()

func (*ListRegistriesResponse) ProtoReflect 

func (x *ListRegistriesResponse) ProtoReflect() protoreflect.Message

func (*ListRegistriesResponse) Reset 

func (x *ListRegistriesResponse) Reset()

func (*ListRegistriesResponse) String 

func (x *ListRegistriesResponse) String() string

type ListSecretVersionsRequest 

type ListSecretVersionsRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSecretVersionsRequest) Descriptor deprecated 

func (*ListSecretVersionsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListSecretVersionsRequest.ProtoReflect.Descriptor instead.

func (*ListSecretVersionsRequest) GetName 

func (x *ListSecretVersionsRequest) GetName() string

func (*ListSecretVersionsRequest) GetNamespace 

func (x *ListSecretVersionsRequest) GetNamespace() string

func (*ListSecretVersionsRequest) ProtoMessage 

func (*ListSecretVersionsRequest) ProtoMessage()

func (*ListSecretVersionsRequest) ProtoReflect 

func (x *ListSecretVersionsRequest) ProtoReflect() protoreflect.Message

func (*ListSecretVersionsRequest) Reset 

func (x *ListSecretVersionsRequest) Reset()

func (*ListSecretVersionsRequest) String 

func (x *ListSecretVersionsRequest) String() string

type ListSecretVersionsResponse 

type ListSecretVersionsResponse struct {

	// Versions are returned newest-first by Secret.version. Plaintext data is
	// omitted; only data_keys is populated. Callers needing plaintext for a
	// specific version must call RevealSecretVersion.
	Versions []*Secret `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions,omitempty"`
	Status   *Status   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSecretVersionsResponse) Descriptor deprecated 

func (*ListSecretVersionsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListSecretVersionsResponse.ProtoReflect.Descriptor instead.

func (*ListSecretVersionsResponse) GetStatus 

func (x *ListSecretVersionsResponse) GetStatus() *Status

func (*ListSecretVersionsResponse) GetVersions 

func (x *ListSecretVersionsResponse) GetVersions() []*Secret

func (*ListSecretVersionsResponse) ProtoMessage 

func (*ListSecretVersionsResponse) ProtoMessage()

func (*ListSecretVersionsResponse) ProtoReflect 

func (x *ListSecretVersionsResponse) ProtoReflect() protoreflect.Message

func (*ListSecretVersionsResponse) Reset 

func (x *ListSecretVersionsResponse) Reset()

func (*ListSecretVersionsResponse) String 

func (x *ListSecretVersionsResponse) String() string

type ListSecretsRequest 

type ListSecretsRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Filter services by label
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Filter services by field
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// Paging parameters
	Paging *PagingParams `protobuf:"bytes,4,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSecretsRequest) Descriptor deprecated 

func (*ListSecretsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListSecretsRequest.ProtoReflect.Descriptor instead.

func (*ListSecretsRequest) GetFieldSelector 

func (x *ListSecretsRequest) GetFieldSelector() map[string]string

func (*ListSecretsRequest) GetLabelSelector 

func (x *ListSecretsRequest) GetLabelSelector() map[string]string

func (*ListSecretsRequest) GetNamespace 

func (x *ListSecretsRequest) GetNamespace() string

func (*ListSecretsRequest) GetPaging 

func (x *ListSecretsRequest) GetPaging() *PagingParams

func (*ListSecretsRequest) ProtoMessage 

func (*ListSecretsRequest) ProtoMessage()

func (*ListSecretsRequest) ProtoReflect 

func (x *ListSecretsRequest) ProtoReflect() protoreflect.Message

func (*ListSecretsRequest) Reset 

func (x *ListSecretsRequest) Reset()

func (*ListSecretsRequest) String 

func (x *ListSecretsRequest) String() string

type ListSecretsResponse 

type ListSecretsResponse struct {
	Secrets []*Secret `protobuf:"bytes,1,rep,name=secrets,proto3" json:"secrets,omitempty"`
	Status  *Status   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSecretsResponse) Descriptor deprecated 

func (*ListSecretsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListSecretsResponse.ProtoReflect.Descriptor instead.

func (*ListSecretsResponse) GetSecrets 

func (x *ListSecretsResponse) GetSecrets() []*Secret

func (*ListSecretsResponse) GetStatus 

func (x *ListSecretsResponse) GetStatus() *Status

func (*ListSecretsResponse) ProtoMessage 

func (*ListSecretsResponse) ProtoMessage()

func (*ListSecretsResponse) ProtoReflect 

func (x *ListSecretsResponse) ProtoReflect() protoreflect.Message

func (*ListSecretsResponse) Reset 

func (x *ListSecretsResponse) Reset()

func (*ListSecretsResponse) String 

func (x *ListSecretsResponse) String() string

type ListServicesRequest 

type ListServicesRequest struct {

	// Namespace to list services from (optional, default: "default")
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Filter services by label
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Filter services by field
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// Paging parameters
	Paging *PagingParams `protobuf:"bytes,4,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

ListServicesRequest requests a list of services.

func (*ListServicesRequest) Descriptor deprecated 

func (*ListServicesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead.

func (*ListServicesRequest) GetFieldSelector 

func (x *ListServicesRequest) GetFieldSelector() map[string]string

func (*ListServicesRequest) GetLabelSelector 

func (x *ListServicesRequest) GetLabelSelector() map[string]string

func (*ListServicesRequest) GetNamespace 

func (x *ListServicesRequest) GetNamespace() string

func (*ListServicesRequest) GetPaging 

func (x *ListServicesRequest) GetPaging() *PagingParams

func (*ListServicesRequest) ProtoMessage 

func (*ListServicesRequest) ProtoMessage()

func (*ListServicesRequest) ProtoReflect 

func (x *ListServicesRequest) ProtoReflect() protoreflect.Message

func (*ListServicesRequest) Reset 

func (x *ListServicesRequest) Reset()

func (*ListServicesRequest) String 

func (x *ListServicesRequest) String() string

type ListServicesResponse 

type ListServicesResponse struct {

	// List of services
	Services []*Service `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// Paging information for continuation
	Paging *PagingParams `protobuf:"bytes,3,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

ListServicesResponse returns a list of services.

func (*ListServicesResponse) Descriptor deprecated 

func (*ListServicesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead.

func (*ListServicesResponse) GetPaging 

func (x *ListServicesResponse) GetPaging() *PagingParams

func (*ListServicesResponse) GetServices 

func (x *ListServicesResponse) GetServices() []*Service

func (*ListServicesResponse) GetStatus 

func (x *ListServicesResponse) GetStatus() *Status

func (*ListServicesResponse) ProtoMessage 

func (*ListServicesResponse) ProtoMessage()

func (*ListServicesResponse) ProtoReflect 

func (x *ListServicesResponse) ProtoReflect() protoreflect.Message

func (*ListServicesResponse) Reset 

func (x *ListServicesResponse) Reset()

func (*ListServicesResponse) String 

func (x *ListServicesResponse) String() string

type ListSnapshotsRequest 

type ListSnapshotsRequest struct {
	Namespace     string            `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	Paging        *PagingParams     `protobuf:"bytes,3,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSnapshotsRequest) Descriptor deprecated 

func (*ListSnapshotsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListSnapshotsRequest.ProtoReflect.Descriptor instead.

func (*ListSnapshotsRequest) GetLabelSelector 

func (x *ListSnapshotsRequest) GetLabelSelector() map[string]string

func (*ListSnapshotsRequest) GetNamespace 

func (x *ListSnapshotsRequest) GetNamespace() string

func (*ListSnapshotsRequest) GetPaging 

func (x *ListSnapshotsRequest) GetPaging() *PagingParams

func (*ListSnapshotsRequest) ProtoMessage 

func (*ListSnapshotsRequest) ProtoMessage()

func (*ListSnapshotsRequest) ProtoReflect 

func (x *ListSnapshotsRequest) ProtoReflect() protoreflect.Message

func (*ListSnapshotsRequest) Reset 

func (x *ListSnapshotsRequest) Reset()

func (*ListSnapshotsRequest) String 

func (x *ListSnapshotsRequest) String() string

type ListSnapshotsResponse 

type ListSnapshotsResponse struct {
	Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
	Status    *Status     `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSnapshotsResponse) Descriptor deprecated 

func (*ListSnapshotsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListSnapshotsResponse.ProtoReflect.Descriptor instead.

func (*ListSnapshotsResponse) GetSnapshots 

func (x *ListSnapshotsResponse) GetSnapshots() []*Snapshot

func (*ListSnapshotsResponse) GetStatus 

func (x *ListSnapshotsResponse) GetStatus() *Status

func (*ListSnapshotsResponse) ProtoMessage 

func (*ListSnapshotsResponse) ProtoMessage()

func (*ListSnapshotsResponse) ProtoReflect 

func (x *ListSnapshotsResponse) ProtoReflect() protoreflect.Message

func (*ListSnapshotsResponse) Reset 

func (x *ListSnapshotsResponse) Reset()

func (*ListSnapshotsResponse) String 

func (x *ListSnapshotsResponse) String() string

type ListStorageClassesRequest 

type ListStorageClassesRequest struct {
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	Paging        *PagingParams     `protobuf:"bytes,2,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

func (*ListStorageClassesRequest) Descriptor deprecated 

func (*ListStorageClassesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListStorageClassesRequest.ProtoReflect.Descriptor instead.

func (*ListStorageClassesRequest) GetLabelSelector 

func (x *ListStorageClassesRequest) GetLabelSelector() map[string]string

func (*ListStorageClassesRequest) GetPaging 

func (x *ListStorageClassesRequest) GetPaging() *PagingParams

func (*ListStorageClassesRequest) ProtoMessage 

func (*ListStorageClassesRequest) ProtoMessage()

func (*ListStorageClassesRequest) ProtoReflect 

func (x *ListStorageClassesRequest) ProtoReflect() protoreflect.Message

func (*ListStorageClassesRequest) Reset 

func (x *ListStorageClassesRequest) Reset()

func (*ListStorageClassesRequest) String 

func (x *ListStorageClassesRequest) String() string

type ListStorageClassesResponse 

type ListStorageClassesResponse struct {
	StorageClasses []*StorageClass `protobuf:"bytes,1,rep,name=storage_classes,json=storageClasses,proto3" json:"storage_classes,omitempty"`
	Status         *Status         `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListStorageClassesResponse) Descriptor deprecated 

func (*ListStorageClassesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListStorageClassesResponse.ProtoReflect.Descriptor instead.

func (*ListStorageClassesResponse) GetStatus 

func (x *ListStorageClassesResponse) GetStatus() *Status

func (*ListStorageClassesResponse) GetStorageClasses 

func (x *ListStorageClassesResponse) GetStorageClasses() []*StorageClass

func (*ListStorageClassesResponse) ProtoMessage 

func (*ListStorageClassesResponse) ProtoMessage()

func (*ListStorageClassesResponse) ProtoReflect 

func (x *ListStorageClassesResponse) ProtoReflect() protoreflect.Message

func (*ListStorageClassesResponse) Reset 

func (x *ListStorageClassesResponse) Reset()

func (*ListStorageClassesResponse) String 

func (x *ListStorageClassesResponse) String() string

type ListVolumesRequest 

type ListVolumesRequest struct {
	Namespace     string            `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	Paging        *PagingParams     `protobuf:"bytes,4,opt,name=paging,proto3" json:"paging,omitempty"`
	// contains filtered or unexported fields
}

func (*ListVolumesRequest) Descriptor deprecated 

func (*ListVolumesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListVolumesRequest) GetFieldSelector 

func (x *ListVolumesRequest) GetFieldSelector() map[string]string

func (*ListVolumesRequest) GetLabelSelector 

func (x *ListVolumesRequest) GetLabelSelector() map[string]string

func (*ListVolumesRequest) GetNamespace 

func (x *ListVolumesRequest) GetNamespace() string

func (*ListVolumesRequest) GetPaging 

func (x *ListVolumesRequest) GetPaging() *PagingParams

func (*ListVolumesRequest) ProtoMessage 

func (*ListVolumesRequest) ProtoMessage()

func (*ListVolumesRequest) ProtoReflect 

func (x *ListVolumesRequest) ProtoReflect() protoreflect.Message

func (*ListVolumesRequest) Reset 

func (x *ListVolumesRequest) Reset()

func (*ListVolumesRequest) String 

func (x *ListVolumesRequest) String() string

type ListVolumesResponse 

type ListVolumesResponse struct {
	Volumes []*Volume `protobuf:"bytes,1,rep,name=volumes,proto3" json:"volumes,omitempty"`
	Status  *Status   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*ListVolumesResponse) Descriptor deprecated 

func (*ListVolumesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListVolumesResponse) GetStatus 

func (x *ListVolumesResponse) GetStatus() *Status

func (*ListVolumesResponse) GetVolumes 

func (x *ListVolumesResponse) GetVolumes() []*Volume

func (*ListVolumesResponse) ProtoMessage 

func (*ListVolumesResponse) ProtoMessage()

func (*ListVolumesResponse) ProtoReflect 

func (x *ListVolumesResponse) ProtoReflect() protoreflect.Message

func (*ListVolumesResponse) Reset 

func (x *ListVolumesResponse) Reset()

func (*ListVolumesResponse) String 

func (x *ListVolumesResponse) String() string

type LogRequest 

type LogRequest struct {

	// Type of log request
	ResourceTarget string `protobuf:"bytes,1,opt,name=resource_target,json=resourceTarget,proto3" json:"resource_target,omitempty"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Follow the log output (like tail -f)
	Follow bool `protobuf:"varint,3,opt,name=follow,proto3" json:"follow,omitempty"`
	// Number of lines to show from the end of the logs (0 for all)
	Tail int32 `protobuf:"varint,4,opt,name=tail,proto3" json:"tail,omitempty"`
	// Show logs since this time (RFC 3339 format)
	Since string `protobuf:"bytes,5,opt,name=since,proto3" json:"since,omitempty"`
	// Show logs until this time (RFC 3339 format)
	Until string `protobuf:"bytes,6,opt,name=until,proto3" json:"until,omitempty"`
	// Include timestamps with logs
	Timestamps bool `protobuf:"varint,7,opt,name=timestamps,proto3" json:"timestamps,omitempty"`
	// Filter logs by text pattern
	Filter string `protobuf:"bytes,8,opt,name=filter,proto3" json:"filter,omitempty"`
	// Client can send updated parameters while streaming
	ParameterUpdate bool `protobuf:"varint,9,opt,name=parameter_update,json=parameterUpdate,proto3" json:"parameter_update,omitempty"`
	// Show container/process logs
	ShowLogs bool `protobuf:"varint,10,opt,name=show_logs,json=showLogs,proto3" json:"show_logs,omitempty"`
	// Show lifecycle events
	ShowEvents bool `protobuf:"varint,11,opt,name=show_events,json=showEvents,proto3" json:"show_events,omitempty"`
	// Show status changes
	ShowStatus bool `protobuf:"varint,12,opt,name=show_status,json=showStatus,proto3" json:"show_status,omitempty"`
	// contains filtered or unexported fields
}

LogRequest represents a request to get logs from a service or instance.

func (*LogRequest) Descriptor deprecated 

func (*LogRequest) Descriptor() ([]byte, []int)

Deprecated: Use LogRequest.ProtoReflect.Descriptor instead.

func (*LogRequest) GetFilter 

func (x *LogRequest) GetFilter() string

func (*LogRequest) GetFollow 

func (x *LogRequest) GetFollow() bool

func (*LogRequest) GetNamespace 

func (x *LogRequest) GetNamespace() string

func (*LogRequest) GetParameterUpdate 

func (x *LogRequest) GetParameterUpdate() bool

func (*LogRequest) GetResourceTarget 

func (x *LogRequest) GetResourceTarget() string

func (*LogRequest) GetShowEvents 

func (x *LogRequest) GetShowEvents() bool

func (*LogRequest) GetShowLogs 

func (x *LogRequest) GetShowLogs() bool

func (*LogRequest) GetShowStatus 

func (x *LogRequest) GetShowStatus() bool

func (*LogRequest) GetSince 

func (x *LogRequest) GetSince() string

func (*LogRequest) GetTail 

func (x *LogRequest) GetTail() int32

func (*LogRequest) GetTimestamps 

func (x *LogRequest) GetTimestamps() bool

func (*LogRequest) GetUntil 

func (x *LogRequest) GetUntil() string

func (*LogRequest) ProtoMessage 

func (*LogRequest) ProtoMessage()

func (*LogRequest) ProtoReflect 

func (x *LogRequest) ProtoReflect() protoreflect.Message

func (*LogRequest) Reset 

func (x *LogRequest) Reset()

func (*LogRequest) String 

func (x *LogRequest) String() string

type LogResponse 

type LogResponse struct {

	// Service name the log is from
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// Instance ID the log is from
	InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
	// Instance name the log is from
	InstanceName string `protobuf:"bytes,3,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
	// Timestamp of the log (RFC 3339 format)
	Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Contents of the log line
	Content string `protobuf:"bytes,5,opt,name=content,proto3" json:"content,omitempty"`
	// Stream (stdout or stderr)
	Stream string `protobuf:"bytes,6,opt,name=stream,proto3" json:"stream,omitempty"`
	// Status code for control messages
	Status *Status `protobuf:"bytes,7,opt,name=status,proto3" json:"status,omitempty"`
	// Log level (info, warning, error, etc.) if applicable
	LogLevel string `protobuf:"bytes,8,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"`
	// contains filtered or unexported fields
}

LogResponse represents a log message in a stream response.

func (*LogResponse) Descriptor deprecated 

func (*LogResponse) Descriptor() ([]byte, []int)

Deprecated: Use LogResponse.ProtoReflect.Descriptor instead.

func (*LogResponse) GetContent 

func (x *LogResponse) GetContent() string

func (*LogResponse) GetInstanceId 

func (x *LogResponse) GetInstanceId() string

func (*LogResponse) GetInstanceName 

func (x *LogResponse) GetInstanceName() string

func (*LogResponse) GetLogLevel 

func (x *LogResponse) GetLogLevel() string

func (*LogResponse) GetServiceName 

func (x *LogResponse) GetServiceName() string

func (*LogResponse) GetStatus 

func (x *LogResponse) GetStatus() *Status

func (*LogResponse) GetStream 

func (x *LogResponse) GetStream() string

func (*LogResponse) GetTimestamp 

func (x *LogResponse) GetTimestamp() string

func (*LogResponse) ProtoMessage 

func (*LogResponse) ProtoMessage()

func (*LogResponse) ProtoReflect 

func (x *LogResponse) ProtoReflect() protoreflect.Message

func (*LogResponse) Reset 

func (x *LogResponse) Reset()

func (*LogResponse) String 

func (x *LogResponse) String() string

type LogServiceClient 

type LogServiceClient interface {
	// StreamLogs provides bidirectional streaming for logs.
	// Clients can stream parameter updates, server streams log content.
	StreamLogs(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[LogRequest, LogResponse], error)
}

LogServiceClient is the client API for LogService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

LogService provides access to service and instance logs.

func NewLogServiceClient 

func NewLogServiceClient(cc grpc.ClientConnInterface) LogServiceClient

type LogServiceServer 

type LogServiceServer interface {
	// StreamLogs provides bidirectional streaming for logs.
	// Clients can stream parameter updates, server streams log content.
	StreamLogs(grpc.BidiStreamingServer[LogRequest, LogResponse]) error
	// contains filtered or unexported methods
}

LogServiceServer is the server API for LogService service. All implementations must embed UnimplementedLogServiceServer for forward compatibility.

LogService provides access to service and instance logs.

type LogService_StreamLogsClient 

type LogService_StreamLogsClient = grpc.BidiStreamingClient[LogRequest, LogResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type LogService_StreamLogsServer 

type LogService_StreamLogsServer = grpc.BidiStreamingServer[LogRequest, LogResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type Mutation 

type Mutation struct {
	Kind         MutationKind `protobuf:"varint,1,opt,name=kind,proto3,enum=rune.api.MutationKind" json:"kind,omitempty"`
	ResourceType string       `protobuf:"bytes,2,opt,name=resource_type,json=resourceType,proto3" json:"resource_type,omitempty"`
	Namespace    string       `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name         string       `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	// Encoded resource bytes (PUT only). Empty for DELETE. The encoding
	// is the same wire format the orderedlog stored.
	Payload []byte `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"`
	// contains filtered or unexported fields
}

Mutation is the per-key effect of an applied operation. Mirrors orderedlog.Mutation.

func (*Mutation) Descriptor deprecated 

func (*Mutation) Descriptor() ([]byte, []int)

Deprecated: Use Mutation.ProtoReflect.Descriptor instead.

func (*Mutation) GetKind 

func (x *Mutation) GetKind() MutationKind

func (*Mutation) GetName 

func (x *Mutation) GetName() string

func (*Mutation) GetNamespace 

func (x *Mutation) GetNamespace() string

func (*Mutation) GetPayload 

func (x *Mutation) GetPayload() []byte

func (*Mutation) GetResourceType 

func (x *Mutation) GetResourceType() string

func (*Mutation) ProtoMessage 

func (*Mutation) ProtoMessage()

func (*Mutation) ProtoReflect 

func (x *Mutation) ProtoReflect() protoreflect.Message

func (*Mutation) Reset 

func (x *Mutation) Reset()

func (*Mutation) String 

func (x *Mutation) String() string

type MutationKind 

type MutationKind int32

Mutation kind, mirrors orderedlog.MutationKind. 

const (
	MutationKind_MUTATION_KIND_UNSPECIFIED MutationKind = 0
	MutationKind_MUTATION_KIND_PUT         MutationKind = 1
	MutationKind_MUTATION_KIND_DELETE      MutationKind = 2
)

func (MutationKind) Descriptor 

func (MutationKind) Descriptor() protoreflect.EnumDescriptor

func (MutationKind) Enum 

func (x MutationKind) Enum() *MutationKind

func (MutationKind) EnumDescriptor deprecated 

func (MutationKind) EnumDescriptor() ([]byte, []int)

Deprecated: Use MutationKind.Descriptor instead.

func (MutationKind) Number 

func (x MutationKind) Number() protoreflect.EnumNumber

func (MutationKind) String 

func (x MutationKind) String() string

func (MutationKind) Type 

func (MutationKind) Type() protoreflect.EnumType

type Namespace 

type Namespace struct {

	// Unique identifier for the namespace
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Human-readable name for the namespace
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Optional description for the namespace
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Labels attached to the namespace for organization
	Labels map[string]string `` /* 139-byte string literal not displayed */
	// Creation timestamp
	CreatedAt int64 `protobuf:"varint,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp
	UpdatedAt int64 `protobuf:"varint,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

Namespace represents a logical boundary for isolation and scoping of resources.

func (*Namespace) Descriptor deprecated 

func (*Namespace) Descriptor() ([]byte, []int)

Deprecated: Use Namespace.ProtoReflect.Descriptor instead.

func (*Namespace) GetCreatedAt 

func (x *Namespace) GetCreatedAt() int64

func (*Namespace) GetDescription 

func (x *Namespace) GetDescription() string

func (*Namespace) GetId 

func (x *Namespace) GetId() string

func (*Namespace) GetLabels 

func (x *Namespace) GetLabels() map[string]string

func (*Namespace) GetName 

func (x *Namespace) GetName() string

func (*Namespace) GetUpdatedAt 

func (x *Namespace) GetUpdatedAt() int64

func (*Namespace) ProtoMessage 

func (*Namespace) ProtoMessage()

func (*Namespace) ProtoReflect 

func (x *Namespace) ProtoReflect() protoreflect.Message

func (*Namespace) Reset 

func (x *Namespace) Reset()

func (*Namespace) String 

func (x *Namespace) String() string

type NamespaceServiceClient 

type NamespaceServiceClient interface {
	// CreateNamespace creates a new namespace.
	CreateNamespace(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error)
	// GetNamespace retrieves a namespace by name.
	GetNamespace(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error)
	// ListNamespaces lists namespaces with optional filtering.
	ListNamespaces(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error)
	// DeleteNamespace deletes a namespace.
	DeleteNamespace(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*DeleteNamespaceResponse, error)
	// WatchNamespaces watches for namespace changes.
	WatchNamespaces(ctx context.Context, in *WatchNamespacesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchNamespacesResponse], error)
}

NamespaceServiceClient is the client API for NamespaceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

NamespaceService provides operations for managing namespaces.

func NewNamespaceServiceClient 

func NewNamespaceServiceClient(cc grpc.ClientConnInterface) NamespaceServiceClient

type NamespaceServiceServer 

type NamespaceServiceServer interface {
	// CreateNamespace creates a new namespace.
	CreateNamespace(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error)
	// GetNamespace retrieves a namespace by name.
	GetNamespace(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error)
	// ListNamespaces lists namespaces with optional filtering.
	ListNamespaces(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error)
	// DeleteNamespace deletes a namespace.
	DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error)
	// WatchNamespaces watches for namespace changes.
	WatchNamespaces(*WatchNamespacesRequest, grpc.ServerStreamingServer[WatchNamespacesResponse]) error
	// contains filtered or unexported methods
}

NamespaceServiceServer is the server API for NamespaceService service. All implementations must embed UnimplementedNamespaceServiceServer for forward compatibility.

NamespaceService provides operations for managing namespaces.

type NamespaceService_WatchNamespacesClient 

type NamespaceService_WatchNamespacesClient = grpc.ServerStreamingClient[WatchNamespacesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type NamespaceService_WatchNamespacesServer 

type NamespaceService_WatchNamespacesServer = grpc.ServerStreamingServer[WatchNamespacesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type NetworkAllocation 

type NetworkAllocation struct {
	ServiceId string `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	Vip       string `protobuf:"bytes,2,opt,name=vip,proto3" json:"vip,omitempty"`
	// contains filtered or unexported fields
}

func (*NetworkAllocation) Descriptor deprecated 

func (*NetworkAllocation) Descriptor() ([]byte, []int)

Deprecated: Use NetworkAllocation.ProtoReflect.Descriptor instead.

func (*NetworkAllocation) GetServiceId 

func (x *NetworkAllocation) GetServiceId() string

func (*NetworkAllocation) GetVip 

func (x *NetworkAllocation) GetVip() string

func (*NetworkAllocation) ProtoMessage 

func (*NetworkAllocation) ProtoMessage()

func (*NetworkAllocation) ProtoReflect 

func (x *NetworkAllocation) ProtoReflect() protoreflect.Message

func (*NetworkAllocation) Reset 

func (x *NetworkAllocation) Reset()

func (*NetworkAllocation) String 

func (x *NetworkAllocation) String() string

type NetworkStatusRequest 

type NetworkStatusRequest struct {
	// contains filtered or unexported fields
}

func (*NetworkStatusRequest) Descriptor deprecated 

func (*NetworkStatusRequest) Descriptor() ([]byte, []int)

Deprecated: Use NetworkStatusRequest.ProtoReflect.Descriptor instead.

func (*NetworkStatusRequest) ProtoMessage 

func (*NetworkStatusRequest) ProtoMessage()

func (*NetworkStatusRequest) ProtoReflect 

func (x *NetworkStatusRequest) ProtoReflect() protoreflect.Message

func (*NetworkStatusRequest) Reset 

func (x *NetworkStatusRequest) Reset()

func (*NetworkStatusRequest) String 

func (x *NetworkStatusRequest) String() string

type NetworkStatusResponse 

type NetworkStatusResponse struct {

	// Cluster service CIDR (e.g. "10.96.0.0/16"). Empty if not bootstrapped.
	Cidr string `protobuf:"bytes,1,opt,name=cidr,proto3" json:"cidr,omitempty"`
	// Currently allocated VIPs (serviceID -> IP).
	Allocations []*NetworkAllocation `protobuf:"bytes,2,rep,name=allocations,proto3" json:"allocations,omitempty"`
	// Free-list size: IPs ready for the next allocation.
	FreeListSize uint32 `protobuf:"varint,3,opt,name=free_list_size,json=freeListSize,proto3" json:"free_list_size,omitempty"`
	// Pending releases waiting on the cooldown window.
	PendingReleases uint32 `protobuf:"varint,4,opt,name=pending_releases,json=pendingReleases,proto3" json:"pending_releases,omitempty"`
	// Total usable IP count carved from the CIDR.
	Capacity uint32 `protobuf:"varint,5,opt,name=capacity,proto3" json:"capacity,omitempty"`
	// contains filtered or unexported fields
}

func (*NetworkStatusResponse) Descriptor deprecated 

func (*NetworkStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use NetworkStatusResponse.ProtoReflect.Descriptor instead.

func (*NetworkStatusResponse) GetAllocations 

func (x *NetworkStatusResponse) GetAllocations() []*NetworkAllocation

func (*NetworkStatusResponse) GetCapacity 

func (x *NetworkStatusResponse) GetCapacity() uint32

func (*NetworkStatusResponse) GetCidr 

func (x *NetworkStatusResponse) GetCidr() string

func (*NetworkStatusResponse) GetFreeListSize 

func (x *NetworkStatusResponse) GetFreeListSize() uint32

func (*NetworkStatusResponse) GetPendingReleases 

func (x *NetworkStatusResponse) GetPendingReleases() uint32

func (*NetworkStatusResponse) ProtoMessage 

func (*NetworkStatusResponse) ProtoMessage()

func (*NetworkStatusResponse) ProtoReflect 

func (x *NetworkStatusResponse) ProtoReflect() protoreflect.Message

func (*NetworkStatusResponse) Reset 

func (x *NetworkStatusResponse) Reset()

func (*NetworkStatusResponse) String 

func (x *NetworkStatusResponse) String() string

type OrderedEvent 

type OrderedEvent struct {

	// Monotonic sequence number assigned by OrderedLog. Use as the
	// resourceVersion equivalent for Watch resume.
	Seq uint64 `protobuf:"varint,1,opt,name=seq,proto3" json:"seq,omitempty"`
	// Operation type identifier (e.g. "AllocateVIP",
	// "PutNetworkPolicy"). The applier on the producer side is the
	// authority on semantics.
	OpType string `protobuf:"bytes,2,opt,name=op_type,json=opType,proto3" json:"op_type,omitempty"`
	// The resulting state mutations.
	Mutations []*Mutation `protobuf:"bytes,3,rep,name=mutations,proto3" json:"mutations,omitempty"`
	// contains filtered or unexported fields
}

OrderedEvent is a successfully replicated control-plane operation.

func (*OrderedEvent) Descriptor deprecated 

func (*OrderedEvent) Descriptor() ([]byte, []int)

Deprecated: Use OrderedEvent.ProtoReflect.Descriptor instead.

func (*OrderedEvent) GetMutations 

func (x *OrderedEvent) GetMutations() []*Mutation

func (*OrderedEvent) GetOpType 

func (x *OrderedEvent) GetOpType() string

func (*OrderedEvent) GetSeq 

func (x *OrderedEvent) GetSeq() uint64

func (*OrderedEvent) ProtoMessage 

func (*OrderedEvent) ProtoMessage()

func (*OrderedEvent) ProtoReflect 

func (x *OrderedEvent) ProtoReflect() protoreflect.Message

func (*OrderedEvent) Reset 

func (x *OrderedEvent) Reset()

func (*OrderedEvent) String 

func (x *OrderedEvent) String() string

type PagingParams 

type PagingParams struct {

	// Maximum number of items to return
	Limit int32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// Offset to start from
	Offset int32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Token for continuation (if limit was applied)
	ContinuationToken string `protobuf:"bytes,3,opt,name=continuation_token,json=continuationToken,proto3" json:"continuation_token,omitempty"`
	// contains filtered or unexported fields
}

Common paging parameters for list operations

func (*PagingParams) Descriptor deprecated 

func (*PagingParams) Descriptor() ([]byte, []int)

Deprecated: Use PagingParams.ProtoReflect.Descriptor instead.

func (*PagingParams) GetContinuationToken 

func (x *PagingParams) GetContinuationToken() string

func (*PagingParams) GetLimit 

func (x *PagingParams) GetLimit() int32

func (*PagingParams) GetOffset 

func (x *PagingParams) GetOffset() int32

func (*PagingParams) ProtoMessage 

func (*PagingParams) ProtoMessage()

func (*PagingParams) ProtoReflect 

func (x *PagingParams) ProtoReflect() protoreflect.Message

func (*PagingParams) Reset 

func (x *PagingParams) Reset()

func (*PagingParams) String 

func (x *PagingParams) String() string

type Policy 

type Policy struct {
	Id          string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string        `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Description string        `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	Rules       []*PolicyRule `protobuf:"bytes,4,rep,name=rules,proto3" json:"rules,omitempty"`
	Builtin     bool          `protobuf:"varint,5,opt,name=builtin,proto3" json:"builtin,omitempty"`
	// contains filtered or unexported fields
}

func (*Policy) Descriptor deprecated 

func (*Policy) Descriptor() ([]byte, []int)

Deprecated: Use Policy.ProtoReflect.Descriptor instead.

func (*Policy) GetBuiltin 

func (x *Policy) GetBuiltin() bool

func (*Policy) GetDescription 

func (x *Policy) GetDescription() string

func (*Policy) GetId 

func (x *Policy) GetId() string

func (*Policy) GetName 

func (x *Policy) GetName() string

func (*Policy) GetRules 

func (x *Policy) GetRules() []*PolicyRule

func (*Policy) ProtoMessage 

func (*Policy) ProtoMessage()

func (*Policy) ProtoReflect 

func (x *Policy) ProtoReflect() protoreflect.Message

func (*Policy) Reset 

func (x *Policy) Reset()

func (*Policy) String 

func (x *Policy) String() string

type PolicyAttachToSubjectRequest 

type PolicyAttachToSubjectRequest struct {
	PolicyId    string `protobuf:"bytes,1,opt,name=policy_id,json=policyId,proto3" json:"policy_id,omitempty"`
	PolicyName  string `protobuf:"bytes,2,opt,name=policy_name,json=policyName,proto3" json:"policy_name,omitempty"`
	SubjectId   string `protobuf:"bytes,3,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`
	SubjectName string `protobuf:"bytes,4,opt,name=subject_name,json=subjectName,proto3" json:"subject_name,omitempty"`
	SubjectKind string `protobuf:"bytes,5,opt,name=subject_kind,json=subjectKind,proto3" json:"subject_kind,omitempty"` // user|service
	// contains filtered or unexported fields
}

func (*PolicyAttachToSubjectRequest) Descriptor deprecated 

func (*PolicyAttachToSubjectRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyAttachToSubjectRequest.ProtoReflect.Descriptor instead.

func (*PolicyAttachToSubjectRequest) GetPolicyId 

func (x *PolicyAttachToSubjectRequest) GetPolicyId() string

func (*PolicyAttachToSubjectRequest) GetPolicyName 

func (x *PolicyAttachToSubjectRequest) GetPolicyName() string

func (*PolicyAttachToSubjectRequest) GetSubjectId 

func (x *PolicyAttachToSubjectRequest) GetSubjectId() string

func (*PolicyAttachToSubjectRequest) GetSubjectKind 

func (x *PolicyAttachToSubjectRequest) GetSubjectKind() string

func (*PolicyAttachToSubjectRequest) GetSubjectName 

func (x *PolicyAttachToSubjectRequest) GetSubjectName() string

func (*PolicyAttachToSubjectRequest) ProtoMessage 

func (*PolicyAttachToSubjectRequest) ProtoMessage()

func (*PolicyAttachToSubjectRequest) ProtoReflect 

func (x *PolicyAttachToSubjectRequest) ProtoReflect() protoreflect.Message

func (*PolicyAttachToSubjectRequest) Reset 

func (x *PolicyAttachToSubjectRequest) Reset()

func (*PolicyAttachToSubjectRequest) String 

func (x *PolicyAttachToSubjectRequest) String() string

type PolicyAttachToSubjectResponse 

type PolicyAttachToSubjectResponse struct {
	Attached bool `protobuf:"varint,1,opt,name=attached,proto3" json:"attached,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyAttachToSubjectResponse) Descriptor deprecated 

func (*PolicyAttachToSubjectResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyAttachToSubjectResponse.ProtoReflect.Descriptor instead.

func (*PolicyAttachToSubjectResponse) GetAttached 

func (x *PolicyAttachToSubjectResponse) GetAttached() bool

func (*PolicyAttachToSubjectResponse) ProtoMessage 

func (*PolicyAttachToSubjectResponse) ProtoMessage()

func (*PolicyAttachToSubjectResponse) ProtoReflect 

func (x *PolicyAttachToSubjectResponse) ProtoReflect() protoreflect.Message

func (*PolicyAttachToSubjectResponse) Reset 

func (x *PolicyAttachToSubjectResponse) Reset()

func (*PolicyAttachToSubjectResponse) String 

func (x *PolicyAttachToSubjectResponse) String() string

type PolicyCreateRequest 

type PolicyCreateRequest struct {
	Policy *Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyCreateRequest) Descriptor deprecated 

func (*PolicyCreateRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyCreateRequest.ProtoReflect.Descriptor instead.

func (*PolicyCreateRequest) GetPolicy 

func (x *PolicyCreateRequest) GetPolicy() *Policy

func (*PolicyCreateRequest) ProtoMessage 

func (*PolicyCreateRequest) ProtoMessage()

func (*PolicyCreateRequest) ProtoReflect 

func (x *PolicyCreateRequest) ProtoReflect() protoreflect.Message

func (*PolicyCreateRequest) Reset 

func (x *PolicyCreateRequest) Reset()

func (*PolicyCreateRequest) String 

func (x *PolicyCreateRequest) String() string

type PolicyCreateResponse 

type PolicyCreateResponse struct {
	Policy *Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyCreateResponse) Descriptor deprecated 

func (*PolicyCreateResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyCreateResponse.ProtoReflect.Descriptor instead.

func (*PolicyCreateResponse) GetPolicy 

func (x *PolicyCreateResponse) GetPolicy() *Policy

func (*PolicyCreateResponse) ProtoMessage 

func (*PolicyCreateResponse) ProtoMessage()

func (*PolicyCreateResponse) ProtoReflect 

func (x *PolicyCreateResponse) ProtoReflect() protoreflect.Message

func (*PolicyCreateResponse) Reset 

func (x *PolicyCreateResponse) Reset()

func (*PolicyCreateResponse) String 

func (x *PolicyCreateResponse) String() string

type PolicyDeleteRequest 

type PolicyDeleteRequest struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyDeleteRequest) Descriptor deprecated 

func (*PolicyDeleteRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyDeleteRequest.ProtoReflect.Descriptor instead.

func (*PolicyDeleteRequest) GetId 

func (x *PolicyDeleteRequest) GetId() string

func (*PolicyDeleteRequest) GetName 

func (x *PolicyDeleteRequest) GetName() string

func (*PolicyDeleteRequest) ProtoMessage 

func (*PolicyDeleteRequest) ProtoMessage()

func (*PolicyDeleteRequest) ProtoReflect 

func (x *PolicyDeleteRequest) ProtoReflect() protoreflect.Message

func (*PolicyDeleteRequest) Reset 

func (x *PolicyDeleteRequest) Reset()

func (*PolicyDeleteRequest) String 

func (x *PolicyDeleteRequest) String() string

type PolicyDeleteResponse 

type PolicyDeleteResponse struct {
	Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyDeleteResponse) Descriptor deprecated 

func (*PolicyDeleteResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyDeleteResponse.ProtoReflect.Descriptor instead.

func (*PolicyDeleteResponse) GetDeleted 

func (x *PolicyDeleteResponse) GetDeleted() bool

func (*PolicyDeleteResponse) ProtoMessage 

func (*PolicyDeleteResponse) ProtoMessage()

func (*PolicyDeleteResponse) ProtoReflect 

func (x *PolicyDeleteResponse) ProtoReflect() protoreflect.Message

func (*PolicyDeleteResponse) Reset 

func (x *PolicyDeleteResponse) Reset()

func (*PolicyDeleteResponse) String 

func (x *PolicyDeleteResponse) String() string

type PolicyDetachFromSubjectRequest 

type PolicyDetachFromSubjectRequest struct {
	PolicyId    string `protobuf:"bytes,1,opt,name=policy_id,json=policyId,proto3" json:"policy_id,omitempty"`
	PolicyName  string `protobuf:"bytes,2,opt,name=policy_name,json=policyName,proto3" json:"policy_name,omitempty"`
	SubjectId   string `protobuf:"bytes,3,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`
	SubjectName string `protobuf:"bytes,4,opt,name=subject_name,json=subjectName,proto3" json:"subject_name,omitempty"`
	SubjectKind string `protobuf:"bytes,5,opt,name=subject_kind,json=subjectKind,proto3" json:"subject_kind,omitempty"` // user|service
	// contains filtered or unexported fields
}

func (*PolicyDetachFromSubjectRequest) Descriptor deprecated 

func (*PolicyDetachFromSubjectRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyDetachFromSubjectRequest.ProtoReflect.Descriptor instead.

func (*PolicyDetachFromSubjectRequest) GetPolicyId 

func (x *PolicyDetachFromSubjectRequest) GetPolicyId() string

func (*PolicyDetachFromSubjectRequest) GetPolicyName 

func (x *PolicyDetachFromSubjectRequest) GetPolicyName() string

func (*PolicyDetachFromSubjectRequest) GetSubjectId 

func (x *PolicyDetachFromSubjectRequest) GetSubjectId() string

func (*PolicyDetachFromSubjectRequest) GetSubjectKind 

func (x *PolicyDetachFromSubjectRequest) GetSubjectKind() string

func (*PolicyDetachFromSubjectRequest) GetSubjectName 

func (x *PolicyDetachFromSubjectRequest) GetSubjectName() string

func (*PolicyDetachFromSubjectRequest) ProtoMessage 

func (*PolicyDetachFromSubjectRequest) ProtoMessage()

func (*PolicyDetachFromSubjectRequest) ProtoReflect 

func (x *PolicyDetachFromSubjectRequest) ProtoReflect() protoreflect.Message

func (*PolicyDetachFromSubjectRequest) Reset 

func (x *PolicyDetachFromSubjectRequest) Reset()

func (*PolicyDetachFromSubjectRequest) String 

func (x *PolicyDetachFromSubjectRequest) String() string

type PolicyDetachFromSubjectResponse 

type PolicyDetachFromSubjectResponse struct {
	Detached bool `protobuf:"varint,1,opt,name=detached,proto3" json:"detached,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyDetachFromSubjectResponse) Descriptor deprecated 

func (*PolicyDetachFromSubjectResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyDetachFromSubjectResponse.ProtoReflect.Descriptor instead.

func (*PolicyDetachFromSubjectResponse) GetDetached 

func (x *PolicyDetachFromSubjectResponse) GetDetached() bool

func (*PolicyDetachFromSubjectResponse) ProtoMessage 

func (*PolicyDetachFromSubjectResponse) ProtoMessage()

func (*PolicyDetachFromSubjectResponse) ProtoReflect 

func (x *PolicyDetachFromSubjectResponse) ProtoReflect() protoreflect.Message

func (*PolicyDetachFromSubjectResponse) Reset 

func (x *PolicyDetachFromSubjectResponse) Reset()

func (*PolicyDetachFromSubjectResponse) String 

func (x *PolicyDetachFromSubjectResponse) String() string

type PolicyGetRequest 

type PolicyGetRequest struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyGetRequest) Descriptor deprecated 

func (*PolicyGetRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyGetRequest.ProtoReflect.Descriptor instead.

func (*PolicyGetRequest) GetId 

func (x *PolicyGetRequest) GetId() string

func (*PolicyGetRequest) GetName 

func (x *PolicyGetRequest) GetName() string

func (*PolicyGetRequest) ProtoMessage 

func (*PolicyGetRequest) ProtoMessage()

func (*PolicyGetRequest) ProtoReflect 

func (x *PolicyGetRequest) ProtoReflect() protoreflect.Message

func (*PolicyGetRequest) Reset 

func (x *PolicyGetRequest) Reset()

func (*PolicyGetRequest) String 

func (x *PolicyGetRequest) String() string

type PolicyGetResponse 

type PolicyGetResponse struct {
	Policy *Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyGetResponse) Descriptor deprecated 

func (*PolicyGetResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyGetResponse.ProtoReflect.Descriptor instead.

func (*PolicyGetResponse) GetPolicy 

func (x *PolicyGetResponse) GetPolicy() *Policy

func (*PolicyGetResponse) ProtoMessage 

func (*PolicyGetResponse) ProtoMessage()

func (*PolicyGetResponse) ProtoReflect 

func (x *PolicyGetResponse) ProtoReflect() protoreflect.Message

func (*PolicyGetResponse) Reset 

func (x *PolicyGetResponse) Reset()

func (*PolicyGetResponse) String 

func (x *PolicyGetResponse) String() string

type PolicyListRequest 

type PolicyListRequest struct {
	// contains filtered or unexported fields
}

func (*PolicyListRequest) Descriptor deprecated 

func (*PolicyListRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyListRequest.ProtoReflect.Descriptor instead.

func (*PolicyListRequest) ProtoMessage 

func (*PolicyListRequest) ProtoMessage()

func (*PolicyListRequest) ProtoReflect 

func (x *PolicyListRequest) ProtoReflect() protoreflect.Message

func (*PolicyListRequest) Reset 

func (x *PolicyListRequest) Reset()

func (*PolicyListRequest) String 

func (x *PolicyListRequest) String() string

type PolicyListResponse 

type PolicyListResponse struct {
	Policies []*Policy `protobuf:"bytes,1,rep,name=policies,proto3" json:"policies,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyListResponse) Descriptor deprecated 

func (*PolicyListResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyListResponse.ProtoReflect.Descriptor instead.

func (*PolicyListResponse) GetPolicies 

func (x *PolicyListResponse) GetPolicies() []*Policy

func (*PolicyListResponse) ProtoMessage 

func (*PolicyListResponse) ProtoMessage()

func (*PolicyListResponse) ProtoReflect 

func (x *PolicyListResponse) ProtoReflect() protoreflect.Message

func (*PolicyListResponse) Reset 

func (x *PolicyListResponse) Reset()

func (*PolicyListResponse) String 

func (x *PolicyListResponse) String() string

type PolicyRule 

type PolicyRule struct {
	Resource  string   `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`   // services|instances|logs|exec|secrets|configmaps|users|policies|namespaces|tokens|health|orchestrator|*
	Verbs     []string `protobuf:"bytes,2,rep,name=verbs,proto3" json:"verbs,omitempty"`         // get|list|create|update|delete|exec|logs|scale|*
	Namespace string   `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"` // optional; * means all
	// contains filtered or unexported fields
}

func (*PolicyRule) Descriptor deprecated 

func (*PolicyRule) Descriptor() ([]byte, []int)

Deprecated: Use PolicyRule.ProtoReflect.Descriptor instead.

func (*PolicyRule) GetNamespace 

func (x *PolicyRule) GetNamespace() string

func (*PolicyRule) GetResource 

func (x *PolicyRule) GetResource() string

func (*PolicyRule) GetVerbs 

func (x *PolicyRule) GetVerbs() []string

func (*PolicyRule) ProtoMessage 

func (*PolicyRule) ProtoMessage()

func (*PolicyRule) ProtoReflect 

func (x *PolicyRule) ProtoReflect() protoreflect.Message

func (*PolicyRule) Reset 

func (x *PolicyRule) Reset()

func (*PolicyRule) String 

func (x *PolicyRule) String() string

type PolicyUpdateRequest 

type PolicyUpdateRequest struct {
	Policy *Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyUpdateRequest) Descriptor deprecated 

func (*PolicyUpdateRequest) Descriptor() ([]byte, []int)

Deprecated: Use PolicyUpdateRequest.ProtoReflect.Descriptor instead.

func (*PolicyUpdateRequest) GetPolicy 

func (x *PolicyUpdateRequest) GetPolicy() *Policy

func (*PolicyUpdateRequest) ProtoMessage 

func (*PolicyUpdateRequest) ProtoMessage()

func (*PolicyUpdateRequest) ProtoReflect 

func (x *PolicyUpdateRequest) ProtoReflect() protoreflect.Message

func (*PolicyUpdateRequest) Reset 

func (x *PolicyUpdateRequest) Reset()

func (*PolicyUpdateRequest) String 

func (x *PolicyUpdateRequest) String() string

type PolicyUpdateResponse 

type PolicyUpdateResponse struct {
	Policy *Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	// contains filtered or unexported fields
}

func (*PolicyUpdateResponse) Descriptor deprecated 

func (*PolicyUpdateResponse) Descriptor() ([]byte, []int)

Deprecated: Use PolicyUpdateResponse.ProtoReflect.Descriptor instead.

func (*PolicyUpdateResponse) GetPolicy 

func (x *PolicyUpdateResponse) GetPolicy() *Policy

func (*PolicyUpdateResponse) ProtoMessage 

func (*PolicyUpdateResponse) ProtoMessage()

func (*PolicyUpdateResponse) ProtoReflect 

func (x *PolicyUpdateResponse) ProtoReflect() protoreflect.Message

func (*PolicyUpdateResponse) Reset 

func (x *PolicyUpdateResponse) Reset()

func (*PolicyUpdateResponse) String 

func (x *PolicyUpdateResponse) String() string

type Probe 

type Probe struct {

	// Type of probe
	Type ProbeType `protobuf:"varint,1,opt,name=type,proto3,enum=rune.api.ProbeType" json:"type,omitempty"`
	// Path for HTTP probes
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// Port to probe
	Port int32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	// Command to execute for command probes
	Command []string `protobuf:"bytes,4,rep,name=command,proto3" json:"command,omitempty"`
	// Initial delay before starting checks
	InitialDelaySeconds int32 `protobuf:"varint,5,opt,name=initial_delay_seconds,json=initialDelaySeconds,proto3" json:"initial_delay_seconds,omitempty"`
	// How often to perform the check
	PeriodSeconds int32 `protobuf:"varint,6,opt,name=period_seconds,json=periodSeconds,proto3" json:"period_seconds,omitempty"`
	// Timeout for the check
	TimeoutSeconds int32 `protobuf:"varint,7,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	// How many consecutive successes are needed to be considered healthy
	SuccessThreshold int32 `protobuf:"varint,8,opt,name=success_threshold,json=successThreshold,proto3" json:"success_threshold,omitempty"`
	// How many consecutive failures are needed to be considered unhealthy
	FailureThreshold int32 `protobuf:"varint,9,opt,name=failure_threshold,json=failureThreshold,proto3" json:"failure_threshold,omitempty"`
	// contains filtered or unexported fields
}

Probe represents a health check probe configuration.

func (*Probe) Descriptor deprecated 

func (*Probe) Descriptor() ([]byte, []int)

Deprecated: Use Probe.ProtoReflect.Descriptor instead.

func (*Probe) GetCommand 

func (x *Probe) GetCommand() []string

func (*Probe) GetFailureThreshold 

func (x *Probe) GetFailureThreshold() int32

func (*Probe) GetInitialDelaySeconds 

func (x *Probe) GetInitialDelaySeconds() int32

func (*Probe) GetPath 

func (x *Probe) GetPath() string

func (*Probe) GetPeriodSeconds 

func (x *Probe) GetPeriodSeconds() int32

func (*Probe) GetPort 

func (x *Probe) GetPort() int32

func (*Probe) GetSuccessThreshold 

func (x *Probe) GetSuccessThreshold() int32

func (*Probe) GetTimeoutSeconds 

func (x *Probe) GetTimeoutSeconds() int32

func (*Probe) GetType 

func (x *Probe) GetType() ProbeType

func (*Probe) ProtoMessage 

func (*Probe) ProtoMessage()

func (*Probe) ProtoReflect 

func (x *Probe) ProtoReflect() protoreflect.Message

func (*Probe) Reset 

func (x *Probe) Reset()

func (*Probe) String 

func (x *Probe) String() string

type ProbeType 

type ProbeType int32

ProbeType defines the type of health check 

const (
	ProbeType_PROBE_TYPE_UNSPECIFIED ProbeType = 0
	ProbeType_PROBE_TYPE_HTTP        ProbeType = 1
	ProbeType_PROBE_TYPE_TCP         ProbeType = 2
	ProbeType_PROBE_TYPE_COMMAND     ProbeType = 3
)

func (ProbeType) Descriptor 

func (ProbeType) Descriptor() protoreflect.EnumDescriptor

func (ProbeType) Enum 

func (x ProbeType) Enum() *ProbeType

func (ProbeType) EnumDescriptor deprecated 

func (ProbeType) EnumDescriptor() ([]byte, []int)

Deprecated: Use ProbeType.Descriptor instead.

func (ProbeType) Number 

func (x ProbeType) Number() protoreflect.EnumNumber

func (ProbeType) String 

func (x ProbeType) String() string

func (ProbeType) Type 

func (ProbeType) Type() protoreflect.EnumType

type ProcessSecurityContext 

type ProcessSecurityContext struct {

	// User to run as
	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// Group to run as
	Group string `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
	// Run with read-only filesystem
	ReadOnlyFs bool `protobuf:"varint,3,opt,name=read_only_fs,json=readOnlyFs,proto3" json:"read_only_fs,omitempty"`
	// Linux capabilities to add
	Capabilities []string `protobuf:"bytes,4,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
	// Allowed syscalls (seccomp)
	AllowedSyscalls []string `protobuf:"bytes,5,rep,name=allowed_syscalls,json=allowedSyscalls,proto3" json:"allowed_syscalls,omitempty"`
	// Denied syscalls (seccomp)
	DeniedSyscalls []string `protobuf:"bytes,6,rep,name=denied_syscalls,json=deniedSyscalls,proto3" json:"denied_syscalls,omitempty"`
	// contains filtered or unexported fields
}

ProcessSecurityContext defines security settings for a process.

func (*ProcessSecurityContext) Descriptor deprecated 

func (*ProcessSecurityContext) Descriptor() ([]byte, []int)

Deprecated: Use ProcessSecurityContext.ProtoReflect.Descriptor instead.

func (*ProcessSecurityContext) GetAllowedSyscalls 

func (x *ProcessSecurityContext) GetAllowedSyscalls() []string

func (*ProcessSecurityContext) GetCapabilities 

func (x *ProcessSecurityContext) GetCapabilities() []string

func (*ProcessSecurityContext) GetDeniedSyscalls 

func (x *ProcessSecurityContext) GetDeniedSyscalls() []string

func (*ProcessSecurityContext) GetGroup 

func (x *ProcessSecurityContext) GetGroup() string

func (*ProcessSecurityContext) GetReadOnlyFs 

func (x *ProcessSecurityContext) GetReadOnlyFs() bool

func (*ProcessSecurityContext) GetUser 

func (x *ProcessSecurityContext) GetUser() string

func (*ProcessSecurityContext) ProtoMessage 

func (*ProcessSecurityContext) ProtoMessage()

func (*ProcessSecurityContext) ProtoReflect 

func (x *ProcessSecurityContext) ProtoReflect() protoreflect.Message

func (*ProcessSecurityContext) Reset 

func (x *ProcessSecurityContext) Reset()

func (*ProcessSecurityContext) String 

func (x *ProcessSecurityContext) String() string

type ProcessSpec 

type ProcessSpec struct {

	// Command to run in the container
	Command string `protobuf:"bytes,1,opt,name=command,proto3" json:"command,omitempty"`
	// Arguments to the command
	Args []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	// Working directory for the command
	WorkingDir string `protobuf:"bytes,3,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"`
	// Security context for the process
	SecurityContext *ProcessSecurityContext `protobuf:"bytes,4,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"`
	// contains filtered or unexported fields
}

ProcessSpec represents process-specific configuration for a service.

func (*ProcessSpec) Descriptor deprecated 

func (*ProcessSpec) Descriptor() ([]byte, []int)

Deprecated: Use ProcessSpec.ProtoReflect.Descriptor instead.

func (*ProcessSpec) GetArgs 

func (x *ProcessSpec) GetArgs() []string

func (*ProcessSpec) GetCommand 

func (x *ProcessSpec) GetCommand() string

func (*ProcessSpec) GetSecurityContext 

func (x *ProcessSpec) GetSecurityContext() *ProcessSecurityContext

func (*ProcessSpec) GetWorkingDir 

func (x *ProcessSpec) GetWorkingDir() string

func (*ProcessSpec) ProtoMessage 

func (*ProcessSpec) ProtoMessage()

func (*ProcessSpec) ProtoReflect 

func (x *ProcessSpec) ProtoReflect() protoreflect.Message

func (*ProcessSpec) Reset 

func (x *ProcessSpec) Reset()

func (*ProcessSpec) String 

func (x *ProcessSpec) String() string

type RegistriesStatusRequest 

type RegistriesStatusRequest struct {
	// contains filtered or unexported fields
}

func (*RegistriesStatusRequest) Descriptor deprecated 

func (*RegistriesStatusRequest) Descriptor() ([]byte, []int)

Deprecated: Use RegistriesStatusRequest.ProtoReflect.Descriptor instead.

func (*RegistriesStatusRequest) ProtoMessage 

func (*RegistriesStatusRequest) ProtoMessage()

func (*RegistriesStatusRequest) ProtoReflect 

func (x *RegistriesStatusRequest) ProtoReflect() protoreflect.Message

func (*RegistriesStatusRequest) Reset 

func (x *RegistriesStatusRequest) Reset()

func (*RegistriesStatusRequest) String 

func (x *RegistriesStatusRequest) String() string

type RegistriesStatusResponse 

type RegistriesStatusResponse struct {
	Registries []*RegistryRuntimeStatus `protobuf:"bytes,1,rep,name=registries,proto3" json:"registries,omitempty"`
	// contains filtered or unexported fields
}

func (*RegistriesStatusResponse) Descriptor deprecated 

func (*RegistriesStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use RegistriesStatusResponse.ProtoReflect.Descriptor instead.

func (*RegistriesStatusResponse) GetRegistries 

func (x *RegistriesStatusResponse) GetRegistries() []*RegistryRuntimeStatus

func (*RegistriesStatusResponse) ProtoMessage 

func (*RegistriesStatusResponse) ProtoMessage()

func (*RegistriesStatusResponse) ProtoReflect 

func (x *RegistriesStatusResponse) ProtoReflect() protoreflect.Message

func (*RegistriesStatusResponse) Reset 

func (x *RegistriesStatusResponse) Reset()

func (*RegistriesStatusResponse) String 

func (x *RegistriesStatusResponse) String() string

type RegistryAuthConfig 

type RegistryAuthConfig struct {
	Type     string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`         // basic | token | ecr | dockerconfigjson (optional; may be inferred)
	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"` // for basic
	Password string `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"` // for basic
	Token    string `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`       // for token
	Region   string `protobuf:"bytes,5,opt,name=region,proto3" json:"region,omitempty"`     // for ecr
	// from_secret is a string reference supporting ResourceRef formats (URI/FQDN/minimal)
	FromSecret string            `protobuf:"bytes,6,opt,name=from_secret,json=fromSecret,proto3" json:"from_secret,omitempty"`
	Bootstrap  bool              `protobuf:"varint,7,opt,name=bootstrap,proto3" json:"bootstrap,omitempty"` // create/update secret from data/env if missing
	Manage     string            `protobuf:"bytes,8,opt,name=manage,proto3" json:"manage,omitempty"`        // create | update | ignore
	Immutable  bool              `protobuf:"varint,9,opt,name=immutable,proto3" json:"immutable,omitempty"` // if true, never overwrite existing secret
	Data       map[string]string ``                                                                         // inline source (typically env-expanded server-side)
	/* 136-byte string literal not displayed */
	// contains filtered or unexported fields
}

Registry admin messages (moved under AdminService)

func (*RegistryAuthConfig) Descriptor deprecated 

func (*RegistryAuthConfig) Descriptor() ([]byte, []int)

Deprecated: Use RegistryAuthConfig.ProtoReflect.Descriptor instead.

func (*RegistryAuthConfig) GetBootstrap 

func (x *RegistryAuthConfig) GetBootstrap() bool

func (*RegistryAuthConfig) GetData 

func (x *RegistryAuthConfig) GetData() map[string]string

func (*RegistryAuthConfig) GetFromSecret 

func (x *RegistryAuthConfig) GetFromSecret() string

func (*RegistryAuthConfig) GetImmutable 

func (x *RegistryAuthConfig) GetImmutable() bool

func (*RegistryAuthConfig) GetManage 

func (x *RegistryAuthConfig) GetManage() string

func (*RegistryAuthConfig) GetPassword 

func (x *RegistryAuthConfig) GetPassword() string

func (*RegistryAuthConfig) GetRegion 

func (x *RegistryAuthConfig) GetRegion() string

func (*RegistryAuthConfig) GetToken 

func (x *RegistryAuthConfig) GetToken() string

func (*RegistryAuthConfig) GetType 

func (x *RegistryAuthConfig) GetType() string

func (*RegistryAuthConfig) GetUsername 

func (x *RegistryAuthConfig) GetUsername() string

func (*RegistryAuthConfig) ProtoMessage 

func (*RegistryAuthConfig) ProtoMessage()

func (*RegistryAuthConfig) ProtoReflect 

func (x *RegistryAuthConfig) ProtoReflect() protoreflect.Message

func (*RegistryAuthConfig) Reset 

func (x *RegistryAuthConfig) Reset()

func (*RegistryAuthConfig) String 

func (x *RegistryAuthConfig) String() string

type RegistryConfig 

type RegistryConfig struct {
	Name     string              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`         // unique registry config name (e.g., ecr-prod)
	Registry string              `protobuf:"bytes,2,opt,name=registry,proto3" json:"registry,omitempty"` // registry host or wildcard (e.g., *.dkr.ecr.us-east-1.amazonaws.com)
	Auth     *RegistryAuthConfig `protobuf:"bytes,3,opt,name=auth,proto3" json:"auth,omitempty"`         // authentication settings
	// contains filtered or unexported fields
}

func (*RegistryConfig) Descriptor deprecated 

func (*RegistryConfig) Descriptor() ([]byte, []int)

Deprecated: Use RegistryConfig.ProtoReflect.Descriptor instead.

func (*RegistryConfig) GetAuth 

func (x *RegistryConfig) GetAuth() *RegistryAuthConfig

func (*RegistryConfig) GetName 

func (x *RegistryConfig) GetName() string

func (*RegistryConfig) GetRegistry 

func (x *RegistryConfig) GetRegistry() string

func (*RegistryConfig) ProtoMessage 

func (*RegistryConfig) ProtoMessage()

func (*RegistryConfig) ProtoReflect 

func (x *RegistryConfig) ProtoReflect() protoreflect.Message

func (*RegistryConfig) Reset 

func (x *RegistryConfig) Reset()

func (*RegistryConfig) String 

func (x *RegistryConfig) String() string

type RegistryRuntimeStatus 

type RegistryRuntimeStatus struct {
	Name            string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Registry        string `protobuf:"bytes,2,opt,name=registry,proto3" json:"registry,omitempty"`
	Type            string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`                                                // derived type (ecr/basic/token/dockerconfigjson)
	AuthConfigured  bool   `protobuf:"varint,4,opt,name=auth_configured,json=authConfigured,proto3" json:"auth_configured,omitempty"`     // whether auth config is present
	LastBootstrapAt string `protobuf:"bytes,5,opt,name=last_bootstrap_at,json=lastBootstrapAt,proto3" json:"last_bootstrap_at,omitempty"` // RFC3339 or empty
	LastError       string `protobuf:"bytes,6,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"`                     // last error (if any)
	// contains filtered or unexported fields
}

func (*RegistryRuntimeStatus) Descriptor deprecated 

func (*RegistryRuntimeStatus) Descriptor() ([]byte, []int)

Deprecated: Use RegistryRuntimeStatus.ProtoReflect.Descriptor instead.

func (*RegistryRuntimeStatus) GetAuthConfigured 

func (x *RegistryRuntimeStatus) GetAuthConfigured() bool

func (*RegistryRuntimeStatus) GetLastBootstrapAt 

func (x *RegistryRuntimeStatus) GetLastBootstrapAt() string

func (*RegistryRuntimeStatus) GetLastError 

func (x *RegistryRuntimeStatus) GetLastError() string

func (*RegistryRuntimeStatus) GetName 

func (x *RegistryRuntimeStatus) GetName() string

func (*RegistryRuntimeStatus) GetRegistry 

func (x *RegistryRuntimeStatus) GetRegistry() string

func (*RegistryRuntimeStatus) GetType 

func (x *RegistryRuntimeStatus) GetType() string

func (*RegistryRuntimeStatus) ProtoMessage 

func (*RegistryRuntimeStatus) ProtoMessage()

func (*RegistryRuntimeStatus) ProtoReflect 

func (x *RegistryRuntimeStatus) ProtoReflect() protoreflect.Message

func (*RegistryRuntimeStatus) Reset 

func (x *RegistryRuntimeStatus) Reset()

func (*RegistryRuntimeStatus) String 

func (x *RegistryRuntimeStatus) String() string

type RemoveRegistryRequest 

type RemoveRegistryRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*RemoveRegistryRequest) Descriptor deprecated 

func (*RemoveRegistryRequest) Descriptor() ([]byte, []int)

Deprecated: Use RemoveRegistryRequest.ProtoReflect.Descriptor instead.

func (*RemoveRegistryRequest) GetName 

func (x *RemoveRegistryRequest) GetName() string

func (*RemoveRegistryRequest) ProtoMessage 

func (*RemoveRegistryRequest) ProtoMessage()

func (*RemoveRegistryRequest) ProtoReflect 

func (x *RemoveRegistryRequest) ProtoReflect() protoreflect.Message

func (*RemoveRegistryRequest) Reset 

func (x *RemoveRegistryRequest) Reset()

func (*RemoveRegistryRequest) String 

func (x *RemoveRegistryRequest) String() string

type RemoveRegistryResponse 

type RemoveRegistryResponse struct {
	Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"`
	// contains filtered or unexported fields
}

func (*RemoveRegistryResponse) Descriptor deprecated 

func (*RemoveRegistryResponse) Descriptor() ([]byte, []int)

Deprecated: Use RemoveRegistryResponse.ProtoReflect.Descriptor instead.

func (*RemoveRegistryResponse) GetDeleted 

func (x *RemoveRegistryResponse) GetDeleted() bool

func (*RemoveRegistryResponse) ProtoMessage 

func (*RemoveRegistryResponse) ProtoMessage()

func (*RemoveRegistryResponse) ProtoReflect 

func (x *RemoveRegistryResponse) ProtoReflect() protoreflect.Message

func (*RemoveRegistryResponse) Reset 

func (x *RemoveRegistryResponse) Reset()

func (*RemoveRegistryResponse) String 

func (x *RemoveRegistryResponse) String() string

type ResolvedConfigMount 

type ResolvedConfigMount struct {

	// Name of the mount (for identification)
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Path where the config should be mounted
	MountPath string `protobuf:"bytes,2,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	// Resolved config data (key -> value)
	Data map[string]string `` /* 135-byte string literal not displayed */
	// Optional: specific keys to project from the config
	Items []*KeyToPath `protobuf:"bytes,4,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

ResolvedConfigMount contains the resolved config data for mounting

func (*ResolvedConfigMount) Descriptor deprecated 

func (*ResolvedConfigMount) Descriptor() ([]byte, []int)

Deprecated: Use ResolvedConfigMount.ProtoReflect.Descriptor instead.

func (*ResolvedConfigMount) GetData 

func (x *ResolvedConfigMount) GetData() map[string]string

func (*ResolvedConfigMount) GetItems 

func (x *ResolvedConfigMount) GetItems() []*KeyToPath

func (*ResolvedConfigMount) GetMountPath 

func (x *ResolvedConfigMount) GetMountPath() string

func (*ResolvedConfigMount) GetName 

func (x *ResolvedConfigMount) GetName() string

func (*ResolvedConfigMount) ProtoMessage 

func (*ResolvedConfigMount) ProtoMessage()

func (*ResolvedConfigMount) ProtoReflect 

func (x *ResolvedConfigMount) ProtoReflect() protoreflect.Message

func (*ResolvedConfigMount) Reset 

func (x *ResolvedConfigMount) Reset()

func (*ResolvedConfigMount) String 

func (x *ResolvedConfigMount) String() string

type ResolvedSecretMount 

type ResolvedSecretMount struct {

	// Name of the mount (for identification)
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Path where the secret should be mounted
	MountPath string `protobuf:"bytes,2,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	// Resolved secret data (key -> value)
	Data map[string]string `` /* 135-byte string literal not displayed */
	// Optional: specific keys to project from the secret
	Items []*KeyToPath `protobuf:"bytes,4,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

ResolvedSecretMount contains the resolved secret data for mounting

func (*ResolvedSecretMount) Descriptor deprecated 

func (*ResolvedSecretMount) Descriptor() ([]byte, []int)

Deprecated: Use ResolvedSecretMount.ProtoReflect.Descriptor instead.

func (*ResolvedSecretMount) GetData 

func (x *ResolvedSecretMount) GetData() map[string]string

func (*ResolvedSecretMount) GetItems 

func (x *ResolvedSecretMount) GetItems() []*KeyToPath

func (*ResolvedSecretMount) GetMountPath 

func (x *ResolvedSecretMount) GetMountPath() string

func (*ResolvedSecretMount) GetName 

func (x *ResolvedSecretMount) GetName() string

func (*ResolvedSecretMount) ProtoMessage 

func (*ResolvedSecretMount) ProtoMessage()

func (*ResolvedSecretMount) ProtoReflect 

func (x *ResolvedSecretMount) ProtoReflect() protoreflect.Message

func (*ResolvedSecretMount) Reset 

func (x *ResolvedSecretMount) Reset()

func (*ResolvedSecretMount) String 

func (x *ResolvedSecretMount) String() string

type ResourceLimit 

type ResourceLimit struct {

	// Requested resources (guaranteed)
	Request string `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Maximum resources (limit)
	Limit string `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// contains filtered or unexported fields
}

ResourceLimit defines request and limit for a resource.

func (*ResourceLimit) Descriptor deprecated 

func (*ResourceLimit) Descriptor() ([]byte, []int)

Deprecated: Use ResourceLimit.ProtoReflect.Descriptor instead.

func (*ResourceLimit) GetLimit 

func (x *ResourceLimit) GetLimit() string

func (*ResourceLimit) GetRequest 

func (x *ResourceLimit) GetRequest() string

func (*ResourceLimit) ProtoMessage 

func (*ResourceLimit) ProtoMessage()

func (*ResourceLimit) ProtoReflect 

func (x *ResourceLimit) ProtoReflect() protoreflect.Message

func (*ResourceLimit) Reset 

func (x *ResourceLimit) Reset()

func (*ResourceLimit) String 

func (x *ResourceLimit) String() string

type ResourceType 

type ResourceType int32

ResourceType represents different resource types in the system 

const (
	ResourceType_RESOURCE_TYPE_UNSPECIFIED ResourceType = 0
	ResourceType_RESOURCE_TYPE_SERVICE     ResourceType = 1
	ResourceType_RESOURCE_TYPE_INSTANCE    ResourceType = 2
	ResourceType_RESOURCE_TYPE_NODE        ResourceType = 3
	ResourceType_RESOURCE_TYPE_SECRET      ResourceType = 4
	ResourceType_RESOURCE_TYPE_CONFIG      ResourceType = 5
)

func (ResourceType) Descriptor 

func (ResourceType) Descriptor() protoreflect.EnumDescriptor

func (ResourceType) Enum 

func (x ResourceType) Enum() *ResourceType

func (ResourceType) EnumDescriptor deprecated 

func (ResourceType) EnumDescriptor() ([]byte, []int)

Deprecated: Use ResourceType.Descriptor instead.

func (ResourceType) Number 

func (x ResourceType) Number() protoreflect.EnumNumber

func (ResourceType) String 

func (x ResourceType) String() string

func (ResourceType) Type 

func (ResourceType) Type() protoreflect.EnumType

type Resources 

type Resources struct {

	// CPU request and limit
	Cpu *ResourceLimit `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"`
	// Memory request and limit
	Memory *ResourceLimit `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"`
	// contains filtered or unexported fields
}

Resources represents resource requirements for a service instance.

func (*Resources) Descriptor deprecated 

func (*Resources) Descriptor() ([]byte, []int)

Deprecated: Use Resources.ProtoReflect.Descriptor instead.

func (*Resources) GetCpu 

func (x *Resources) GetCpu() *ResourceLimit

func (*Resources) GetMemory 

func (x *Resources) GetMemory() *ResourceLimit

func (*Resources) ProtoMessage 

func (*Resources) ProtoMessage()

func (*Resources) ProtoReflect 

func (x *Resources) ProtoReflect() protoreflect.Message

func (*Resources) Reset 

func (x *Resources) Reset()

func (*Resources) String 

func (x *Resources) String() string

type RestartPolicy 

type RestartPolicy int32

RestartPolicy defines the restart policy for a service. 

const (
	RestartPolicy_RESTART_POLICY_UNSPECIFIED RestartPolicy = 0
	RestartPolicy_RESTART_POLICY_ALWAYS      RestartPolicy = 1
	RestartPolicy_RESTART_POLICY_ON_FAILURE  RestartPolicy = 2
	RestartPolicy_RESTART_POLICY_NEVER       RestartPolicy = 3
)

func (RestartPolicy) Descriptor 

func (RestartPolicy) Descriptor() protoreflect.EnumDescriptor

func (RestartPolicy) Enum 

func (x RestartPolicy) Enum() *RestartPolicy

func (RestartPolicy) EnumDescriptor deprecated 

func (RestartPolicy) EnumDescriptor() ([]byte, []int)

Deprecated: Use RestartPolicy.Descriptor instead.

func (RestartPolicy) Number 

func (x RestartPolicy) Number() protoreflect.EnumNumber

func (RestartPolicy) String 

func (x RestartPolicy) String() string

func (RestartPolicy) Type 

func (RestartPolicy) Type() protoreflect.EnumType

type RestoreVolumeRequest 

type RestoreVolumeRequest struct {
	SnapshotName      string            `protobuf:"bytes,1,opt,name=snapshot_name,json=snapshotName,proto3" json:"snapshot_name,omitempty"`
	SnapshotNamespace string            `protobuf:"bytes,2,opt,name=snapshot_namespace,json=snapshotNamespace,proto3" json:"snapshot_namespace,omitempty"`
	TargetVolumeName  string            `protobuf:"bytes,3,opt,name=target_volume_name,json=targetVolumeName,proto3" json:"target_volume_name,omitempty"`
	TargetNamespace   string            `protobuf:"bytes,4,opt,name=target_namespace,json=targetNamespace,proto3" json:"target_namespace,omitempty"`
	Labels            map[string]string `` /* 139-byte string literal not displayed */
	// StorageClassName overrides the snapshot's class on the restored
	// Volume. Empty defers to the source volume's class.
	StorageClassName string `protobuf:"bytes,6,opt,name=storage_class_name,json=storageClassName,proto3" json:"storage_class_name,omitempty"`
	// contains filtered or unexported fields
}

RestoreVolumeRequest provisions a NEW Volume from an existing Snapshot. The new Volume lives in target_namespace (defaults to the snapshot's namespace when empty) under target_volume_name. The controller picks up the resulting Pending volume, calls Driver.RestoreFromSnapshot, and transitions the volume to Available with the restored handle.

func (*RestoreVolumeRequest) Descriptor deprecated 

func (*RestoreVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use RestoreVolumeRequest.ProtoReflect.Descriptor instead.

func (*RestoreVolumeRequest) GetLabels 

func (x *RestoreVolumeRequest) GetLabels() map[string]string

func (*RestoreVolumeRequest) GetSnapshotName 

func (x *RestoreVolumeRequest) GetSnapshotName() string

func (*RestoreVolumeRequest) GetSnapshotNamespace 

func (x *RestoreVolumeRequest) GetSnapshotNamespace() string

func (*RestoreVolumeRequest) GetStorageClassName 

func (x *RestoreVolumeRequest) GetStorageClassName() string

func (*RestoreVolumeRequest) GetTargetNamespace 

func (x *RestoreVolumeRequest) GetTargetNamespace() string

func (*RestoreVolumeRequest) GetTargetVolumeName 

func (x *RestoreVolumeRequest) GetTargetVolumeName() string

func (*RestoreVolumeRequest) ProtoMessage 

func (*RestoreVolumeRequest) ProtoMessage()

func (*RestoreVolumeRequest) ProtoReflect 

func (x *RestoreVolumeRequest) ProtoReflect() protoreflect.Message

func (*RestoreVolumeRequest) Reset 

func (x *RestoreVolumeRequest) Reset()

func (*RestoreVolumeRequest) String 

func (x *RestoreVolumeRequest) String() string

type RetryProvisionVolumeRequest 

type RetryProvisionVolumeRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

RetryProvisionVolumeRequest resets a Failed/Stalled volume back to Pending so the controller will attempt provisioning again.

func (*RetryProvisionVolumeRequest) Descriptor deprecated 

func (*RetryProvisionVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use RetryProvisionVolumeRequest.ProtoReflect.Descriptor instead.

func (*RetryProvisionVolumeRequest) GetName 

func (x *RetryProvisionVolumeRequest) GetName() string

func (*RetryProvisionVolumeRequest) GetNamespace 

func (x *RetryProvisionVolumeRequest) GetNamespace() string

func (*RetryProvisionVolumeRequest) ProtoMessage 

func (*RetryProvisionVolumeRequest) ProtoMessage()

func (*RetryProvisionVolumeRequest) ProtoReflect 

func (x *RetryProvisionVolumeRequest) ProtoReflect() protoreflect.Message

func (*RetryProvisionVolumeRequest) Reset 

func (x *RetryProvisionVolumeRequest) Reset()

func (*RetryProvisionVolumeRequest) String 

func (x *RetryProvisionVolumeRequest) String() string

type RevealSecretRequest 

type RevealSecretRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// contains filtered or unexported fields
}

func (*RevealSecretRequest) Descriptor deprecated 

func (*RevealSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use RevealSecretRequest.ProtoReflect.Descriptor instead.

func (*RevealSecretRequest) GetName 

func (x *RevealSecretRequest) GetName() string

func (*RevealSecretRequest) GetNamespace 

func (x *RevealSecretRequest) GetNamespace() string

func (*RevealSecretRequest) ProtoMessage 

func (*RevealSecretRequest) ProtoMessage()

func (*RevealSecretRequest) ProtoReflect 

func (x *RevealSecretRequest) ProtoReflect() protoreflect.Message

func (*RevealSecretRequest) Reset 

func (x *RevealSecretRequest) Reset()

func (*RevealSecretRequest) String 

func (x *RevealSecretRequest) String() string

type RevealSecretVersionRequest 

type RevealSecretVersionRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Version   int32  `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

func (*RevealSecretVersionRequest) Descriptor deprecated 

func (*RevealSecretVersionRequest) Descriptor() ([]byte, []int)

Deprecated: Use RevealSecretVersionRequest.ProtoReflect.Descriptor instead.

func (*RevealSecretVersionRequest) GetName 

func (x *RevealSecretVersionRequest) GetName() string

func (*RevealSecretVersionRequest) GetNamespace 

func (x *RevealSecretVersionRequest) GetNamespace() string

func (*RevealSecretVersionRequest) GetVersion 

func (x *RevealSecretVersionRequest) GetVersion() int32

func (*RevealSecretVersionRequest) ProtoMessage 

func (*RevealSecretVersionRequest) ProtoMessage()

func (*RevealSecretVersionRequest) ProtoReflect 

func (x *RevealSecretVersionRequest) ProtoReflect() protoreflect.Message

func (*RevealSecretVersionRequest) Reset 

func (x *RevealSecretVersionRequest) Reset()

func (*RevealSecretVersionRequest) String 

func (x *RevealSecretVersionRequest) String() string

type RevokeTokenRequest 

type RevokeTokenRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*RevokeTokenRequest) Descriptor deprecated 

func (*RevokeTokenRequest) Descriptor() ([]byte, []int)

Deprecated: Use RevokeTokenRequest.ProtoReflect.Descriptor instead.

func (*RevokeTokenRequest) GetId 

func (x *RevokeTokenRequest) GetId() string

func (*RevokeTokenRequest) ProtoMessage 

func (*RevokeTokenRequest) ProtoMessage()

func (*RevokeTokenRequest) ProtoReflect 

func (x *RevokeTokenRequest) ProtoReflect() protoreflect.Message

func (*RevokeTokenRequest) Reset 

func (x *RevokeTokenRequest) Reset()

func (*RevokeTokenRequest) String 

func (x *RevokeTokenRequest) String() string

type RevokeTokenResponse 

type RevokeTokenResponse struct {
	Revoked bool `protobuf:"varint,1,opt,name=revoked,proto3" json:"revoked,omitempty"`
	// contains filtered or unexported fields
}

func (*RevokeTokenResponse) Descriptor deprecated 

func (*RevokeTokenResponse) Descriptor() ([]byte, []int)

Deprecated: Use RevokeTokenResponse.ProtoReflect.Descriptor instead.

func (*RevokeTokenResponse) GetRevoked 

func (x *RevokeTokenResponse) GetRevoked() bool

func (*RevokeTokenResponse) ProtoMessage 

func (*RevokeTokenResponse) ProtoMessage()

func (*RevokeTokenResponse) ProtoReflect 

func (x *RevokeTokenResponse) ProtoReflect() protoreflect.Message

func (*RevokeTokenResponse) Reset 

func (x *RevokeTokenResponse) Reset()

func (*RevokeTokenResponse) String 

func (x *RevokeTokenResponse) String() string

type RollbackSecretRequest 

type RollbackSecretRequest struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// to_version is the historical version number to rewrite into a new HEAD.
	// The rollback writes a brand-new version (head+1) carrying the prior
	// version's data; old versions are retained in history.
	ToVersion int32 `protobuf:"varint,3,opt,name=to_version,json=toVersion,proto3" json:"to_version,omitempty"`
	// contains filtered or unexported fields
}

func (*RollbackSecretRequest) Descriptor deprecated 

func (*RollbackSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use RollbackSecretRequest.ProtoReflect.Descriptor instead.

func (*RollbackSecretRequest) GetName 

func (x *RollbackSecretRequest) GetName() string

func (*RollbackSecretRequest) GetNamespace 

func (x *RollbackSecretRequest) GetNamespace() string

func (*RollbackSecretRequest) GetToVersion 

func (x *RollbackSecretRequest) GetToVersion() int32

func (*RollbackSecretRequest) ProtoMessage 

func (*RollbackSecretRequest) ProtoMessage()

func (*RollbackSecretRequest) ProtoReflect 

func (x *RollbackSecretRequest) ProtoReflect() protoreflect.Message

func (*RollbackSecretRequest) Reset 

func (x *RollbackSecretRequest) Reset()

func (*RollbackSecretRequest) String 

func (x *RollbackSecretRequest) String() string

type RunIfSpec 

type RunIfSpec struct {

	// Predicate type. Empty defaults to "freshVolume". Valid values:
	// "freshVolume" | "fileMissing" | "always".
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// Absolute in-container path tested when type=fileMissing.
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// Optional named parent volume that restricts the fileMissing check.
	Volume string `protobuf:"bytes,3,opt,name=volume,proto3" json:"volume,omitempty"`
	// contains filtered or unexported fields
}

RunIfSpec encodes the predicate that decides whether an InitStep runs on a given instance start. Mirrors types.RunIf.

func (*RunIfSpec) Descriptor deprecated 

func (*RunIfSpec) Descriptor() ([]byte, []int)

Deprecated: Use RunIfSpec.ProtoReflect.Descriptor instead.

func (*RunIfSpec) GetPath 

func (x *RunIfSpec) GetPath() string

func (*RunIfSpec) GetType 

func (x *RunIfSpec) GetType() string

func (*RunIfSpec) GetVolume 

func (x *RunIfSpec) GetVolume() string

func (*RunIfSpec) ProtoMessage 

func (*RunIfSpec) ProtoMessage()

func (*RunIfSpec) ProtoReflect 

func (x *RunIfSpec) ProtoReflect() protoreflect.Message

func (*RunIfSpec) Reset 

func (x *RunIfSpec) Reset()

func (*RunIfSpec) String 

func (x *RunIfSpec) String() string

type ScaleServiceRequest 

type ScaleServiceRequest struct {

	// Name of the service to scale
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Number of instances to scale to
	Scale int32 `protobuf:"varint,3,opt,name=scale,proto3" json:"scale,omitempty"`
	// Scaling mode (immediate or gradual)
	Mode ScalingMode `protobuf:"varint,4,opt,name=mode,proto3,enum=rune.api.ScalingMode" json:"mode,omitempty"`
	// Step size for gradual scaling (only used when mode is SCALING_MODE_GRADUAL)
	StepSize int32 `protobuf:"varint,5,opt,name=step_size,json=stepSize,proto3" json:"step_size,omitempty"`
	// Interval between scaling steps in seconds (only used when mode is SCALING_MODE_GRADUAL)
	IntervalSeconds int32 `protobuf:"varint,6,opt,name=interval_seconds,json=intervalSeconds,proto3" json:"interval_seconds,omitempty"`
	// contains filtered or unexported fields
}

ScaleServiceRequest requests a change in service scale.

func (*ScaleServiceRequest) Descriptor deprecated 

func (*ScaleServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use ScaleServiceRequest.ProtoReflect.Descriptor instead.

func (*ScaleServiceRequest) GetIntervalSeconds 

func (x *ScaleServiceRequest) GetIntervalSeconds() int32

func (*ScaleServiceRequest) GetMode 

func (x *ScaleServiceRequest) GetMode() ScalingMode

func (*ScaleServiceRequest) GetName 

func (x *ScaleServiceRequest) GetName() string

func (*ScaleServiceRequest) GetNamespace 

func (x *ScaleServiceRequest) GetNamespace() string

func (*ScaleServiceRequest) GetScale 

func (x *ScaleServiceRequest) GetScale() int32

func (*ScaleServiceRequest) GetStepSize 

func (x *ScaleServiceRequest) GetStepSize() int32

func (*ScaleServiceRequest) ProtoMessage 

func (*ScaleServiceRequest) ProtoMessage()

func (*ScaleServiceRequest) ProtoReflect 

func (x *ScaleServiceRequest) ProtoReflect() protoreflect.Message

func (*ScaleServiceRequest) Reset 

func (x *ScaleServiceRequest) Reset()

func (*ScaleServiceRequest) String 

func (x *ScaleServiceRequest) String() string

type ScalingMode 

type ScalingMode int32

ScalingMode defines how the scaling operation should be performed. 

const (
	// Scaling mode not specified (defaults to SCALING_MODE_IMMEDIATE)
	ScalingMode_SCALING_MODE_UNSPECIFIED ScalingMode = 0
	// Scale to the target immediately
	ScalingMode_SCALING_MODE_IMMEDIATE ScalingMode = 1
	// Scale gradually using the specified step size and interval
	ScalingMode_SCALING_MODE_GRADUAL ScalingMode = 2
)

func (ScalingMode) Descriptor 

func (ScalingMode) Descriptor() protoreflect.EnumDescriptor

func (ScalingMode) Enum 

func (x ScalingMode) Enum() *ScalingMode

func (ScalingMode) EnumDescriptor deprecated 

func (ScalingMode) EnumDescriptor() ([]byte, []int)

Deprecated: Use ScalingMode.Descriptor instead.

func (ScalingMode) Number 

func (x ScalingMode) Number() protoreflect.EnumNumber

func (ScalingMode) String 

func (x ScalingMode) String() string

func (ScalingMode) Type 

func (ScalingMode) Type() protoreflect.EnumType

type ScalingStatusResponse 

type ScalingStatusResponse struct {

	// The current scale
	CurrentScale int32 `protobuf:"varint,1,opt,name=current_scale,json=currentScale,proto3" json:"current_scale,omitempty"`
	// The target scale
	TargetScale int32 `protobuf:"varint,2,opt,name=target_scale,json=targetScale,proto3" json:"target_scale,omitempty"`
	// The number of running instances
	RunningInstances int32 `protobuf:"varint,3,opt,name=running_instances,json=runningInstances,proto3" json:"running_instances,omitempty"`
	// The number of pending instances
	PendingInstances int32 `protobuf:"varint,4,opt,name=pending_instances,json=pendingInstances,proto3" json:"pending_instances,omitempty"`
	// Whether the scaling operation is complete
	Complete bool `protobuf:"varint,5,opt,name=complete,proto3" json:"complete,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

ScalingStatusResponse returns the current scaling status.

func (*ScalingStatusResponse) Descriptor deprecated 

func (*ScalingStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use ScalingStatusResponse.ProtoReflect.Descriptor instead.

func (*ScalingStatusResponse) GetComplete 

func (x *ScalingStatusResponse) GetComplete() bool

func (*ScalingStatusResponse) GetCurrentScale 

func (x *ScalingStatusResponse) GetCurrentScale() int32

func (*ScalingStatusResponse) GetPendingInstances 

func (x *ScalingStatusResponse) GetPendingInstances() int32

func (*ScalingStatusResponse) GetRunningInstances 

func (x *ScalingStatusResponse) GetRunningInstances() int32

func (*ScalingStatusResponse) GetStatus 

func (x *ScalingStatusResponse) GetStatus() *Status

func (*ScalingStatusResponse) GetTargetScale 

func (x *ScalingStatusResponse) GetTargetScale() int32

func (*ScalingStatusResponse) ProtoMessage 

func (*ScalingStatusResponse) ProtoMessage()

func (*ScalingStatusResponse) ProtoReflect 

func (x *ScalingStatusResponse) ProtoReflect() protoreflect.Message

func (*ScalingStatusResponse) Reset 

func (x *ScalingStatusResponse) Reset()

func (*ScalingStatusResponse) String 

func (x *ScalingStatusResponse) String() string

type SeccompProfile 

type SeccompProfile struct {

	// Type selects the profile family. Valid values:
	//
	//	""             — runtime default
	//	"default"      — explicit runtime default
	//	"unconfined"   — disable seccomp filtering (admin-gated)
	//	"localhost"    — load the profile at LocalhostProfile on the host
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// LocalhostProfile is the absolute path to a JSON seccomp profile
	// on the runtime host. Required iff type="localhost".
	LocalhostProfile string `protobuf:"bytes,2,opt,name=localhost_profile,json=localhostProfile,proto3" json:"localhost_profile,omitempty"`
	// contains filtered or unexported fields
}

SeccompProfile selects the seccomp policy applied to a container. Empty / unset means the platform default profile is used.

func (*SeccompProfile) Descriptor deprecated 

func (*SeccompProfile) Descriptor() ([]byte, []int)

Deprecated: Use SeccompProfile.ProtoReflect.Descriptor instead.

func (*SeccompProfile) GetLocalhostProfile 

func (x *SeccompProfile) GetLocalhostProfile() string

func (*SeccompProfile) GetType 

func (x *SeccompProfile) GetType() string

func (*SeccompProfile) ProtoMessage 

func (*SeccompProfile) ProtoMessage()

func (*SeccompProfile) ProtoReflect 

func (x *SeccompProfile) ProtoReflect() protoreflect.Message

func (*SeccompProfile) Reset 

func (x *SeccompProfile) Reset()

func (*SeccompProfile) String 

func (x *SeccompProfile) String() string

type Secret 

type Secret struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Type      string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` // "static" for MVP
	// data is the plaintext secret payload. Only populated by RevealSecret responses
	// and by client-supplied Create/Update requests. Get/List return it empty;
	// metadata callers should use data_keys instead.
	Data      map[string]string `` /* 135-byte string literal not displayed */
	Version   int32             `protobuf:"varint,5,opt,name=version,proto3" json:"version,omitempty"`
	CreatedAt string            `protobuf:"bytes,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt string            `protobuf:"bytes,7,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// data_keys lists the keys present in data without revealing values.
	// Populated by Get/List/Reveal responses; ignored on Create/Update requests.
	DataKeys []string `protobuf:"bytes,8,rep,name=data_keys,json=dataKeys,proto3" json:"data_keys,omitempty"`
	// contains filtered or unexported fields
}

func (*Secret) Descriptor deprecated 

func (*Secret) Descriptor() ([]byte, []int)

Deprecated: Use Secret.ProtoReflect.Descriptor instead.

func (*Secret) GetCreatedAt 

func (x *Secret) GetCreatedAt() string

func (*Secret) GetData 

func (x *Secret) GetData() map[string]string

func (*Secret) GetDataKeys 

func (x *Secret) GetDataKeys() []string

func (*Secret) GetName 

func (x *Secret) GetName() string

func (*Secret) GetNamespace 

func (x *Secret) GetNamespace() string

func (*Secret) GetType 

func (x *Secret) GetType() string

func (*Secret) GetUpdatedAt 

func (x *Secret) GetUpdatedAt() string

func (*Secret) GetVersion 

func (x *Secret) GetVersion() int32

func (*Secret) ProtoMessage 

func (*Secret) ProtoMessage()

func (*Secret) ProtoReflect 

func (x *Secret) ProtoReflect() protoreflect.Message

func (*Secret) Reset 

func (x *Secret) Reset()

func (*Secret) String 

func (x *Secret) String() string

type SecretMount 

type SecretMount struct {
	Name       string       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	MountPath  string       `protobuf:"bytes,2,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	SecretName string       `protobuf:"bytes,3,opt,name=secret_name,json=secretName,proto3" json:"secret_name,omitempty"`
	Items      []*KeyToPath `protobuf:"bytes,4,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

SecretMount defines a secret to be mounted in a container.

func (*SecretMount) Descriptor deprecated 

func (*SecretMount) Descriptor() ([]byte, []int)

Deprecated: Use SecretMount.ProtoReflect.Descriptor instead.

func (*SecretMount) GetItems 

func (x *SecretMount) GetItems() []*KeyToPath

func (*SecretMount) GetMountPath 

func (x *SecretMount) GetMountPath() string

func (*SecretMount) GetName 

func (x *SecretMount) GetName() string

func (*SecretMount) GetSecretName 

func (x *SecretMount) GetSecretName() string

func (*SecretMount) ProtoMessage 

func (*SecretMount) ProtoMessage()

func (*SecretMount) ProtoReflect 

func (x *SecretMount) ProtoReflect() protoreflect.Message

func (*SecretMount) Reset 

func (x *SecretMount) Reset()

func (*SecretMount) String 

func (x *SecretMount) String() string

type SecretResponse 

type SecretResponse struct {
	Secret *Secret `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*SecretResponse) Descriptor deprecated 

func (*SecretResponse) Descriptor() ([]byte, []int)

Deprecated: Use SecretResponse.ProtoReflect.Descriptor instead.

func (*SecretResponse) GetSecret 

func (x *SecretResponse) GetSecret() *Secret

func (*SecretResponse) GetStatus 

func (x *SecretResponse) GetStatus() *Status

func (*SecretResponse) ProtoMessage 

func (*SecretResponse) ProtoMessage()

func (*SecretResponse) ProtoReflect 

func (x *SecretResponse) ProtoReflect() protoreflect.Message

func (*SecretResponse) Reset 

func (x *SecretResponse) Reset()

func (*SecretResponse) String 

func (x *SecretResponse) String() string

type SecretServiceClient 

type SecretServiceClient interface {
	CreateSecret(ctx context.Context, in *CreateSecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	// GetSecret returns secret metadata only (no plaintext data). Use RevealSecret
	// to retrieve the plaintext payload; callers must hold the secrets:reveal verb.
	GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	UpdateSecret(ctx context.Context, in *UpdateSecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	DeleteSecret(ctx context.Context, in *DeleteSecretRequest, opts ...grpc.CallOption) (*Status, error)
	// ListSecrets returns secret metadata only (no plaintext data).
	ListSecrets(ctx context.Context, in *ListSecretsRequest, opts ...grpc.CallOption) (*ListSecretsResponse, error)
	// RevealSecret returns the plaintext data map for a single secret. Requires
	// the secrets:reveal verb. Each successful call emits an audit event.
	RevealSecret(ctx context.Context, in *RevealSecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	// ListSecretVersions returns metadata for every historical version, newest
	// first. Gated by secrets:get.
	ListSecretVersions(ctx context.Context, in *ListSecretVersionsRequest, opts ...grpc.CallOption) (*ListSecretVersionsResponse, error)
	// RevealSecretVersion returns the plaintext payload of a specific historical
	// version. Gated by secrets:reveal.
	RevealSecretVersion(ctx context.Context, in *RevealSecretVersionRequest, opts ...grpc.CallOption) (*SecretResponse, error)
	// RollbackSecret rewrites HEAD to the contents of a prior version, producing
	// a new version. Gated by secrets:update; emits a `rollback` audit event.
	RollbackSecret(ctx context.Context, in *RollbackSecretRequest, opts ...grpc.CallOption) (*SecretResponse, error)
}

SecretServiceClient is the client API for SecretService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewSecretServiceClient 

func NewSecretServiceClient(cc grpc.ClientConnInterface) SecretServiceClient

type SecretServiceServer 

type SecretServiceServer interface {
	CreateSecret(context.Context, *CreateSecretRequest) (*SecretResponse, error)
	// GetSecret returns secret metadata only (no plaintext data). Use RevealSecret
	// to retrieve the plaintext payload; callers must hold the secrets:reveal verb.
	GetSecret(context.Context, *GetSecretRequest) (*SecretResponse, error)
	UpdateSecret(context.Context, *UpdateSecretRequest) (*SecretResponse, error)
	DeleteSecret(context.Context, *DeleteSecretRequest) (*Status, error)
	// ListSecrets returns secret metadata only (no plaintext data).
	ListSecrets(context.Context, *ListSecretsRequest) (*ListSecretsResponse, error)
	// RevealSecret returns the plaintext data map for a single secret. Requires
	// the secrets:reveal verb. Each successful call emits an audit event.
	RevealSecret(context.Context, *RevealSecretRequest) (*SecretResponse, error)
	// ListSecretVersions returns metadata for every historical version, newest
	// first. Gated by secrets:get.
	ListSecretVersions(context.Context, *ListSecretVersionsRequest) (*ListSecretVersionsResponse, error)
	// RevealSecretVersion returns the plaintext payload of a specific historical
	// version. Gated by secrets:reveal.
	RevealSecretVersion(context.Context, *RevealSecretVersionRequest) (*SecretResponse, error)
	// RollbackSecret rewrites HEAD to the contents of a prior version, producing
	// a new version. Gated by secrets:update; emits a `rollback` audit event.
	RollbackSecret(context.Context, *RollbackSecretRequest) (*SecretResponse, error)
	// contains filtered or unexported methods
}

SecretServiceServer is the server API for SecretService service. All implementations must embed UnimplementedSecretServiceServer for forward compatibility.

type SecurityContext 

type SecurityContext struct {
	SeccompProfile *SeccompProfile `protobuf:"bytes,1,opt,name=seccomp_profile,json=seccompProfile,proto3" json:"seccomp_profile,omitempty"`
	CapAdd         []string        `protobuf:"bytes,2,rep,name=cap_add,json=capAdd,proto3" json:"cap_add,omitempty"`
	CapDrop        []string        `protobuf:"bytes,3,rep,name=cap_drop,json=capDrop,proto3" json:"cap_drop,omitempty"`
	Privileged     bool            `protobuf:"varint,4,opt,name=privileged,proto3" json:"privileged,omitempty"`
	// contains filtered or unexported fields
}

SecurityContext bundles container-level security knobs. Privileged and SeccompProfile=unconfined are gated behind the services.privileged policy verb.

func (*SecurityContext) Descriptor deprecated 

func (*SecurityContext) Descriptor() ([]byte, []int)

Deprecated: Use SecurityContext.ProtoReflect.Descriptor instead.

func (*SecurityContext) GetCapAdd 

func (x *SecurityContext) GetCapAdd() []string

func (*SecurityContext) GetCapDrop 

func (x *SecurityContext) GetCapDrop() []string

func (*SecurityContext) GetPrivileged 

func (x *SecurityContext) GetPrivileged() bool

func (*SecurityContext) GetSeccompProfile 

func (x *SecurityContext) GetSeccompProfile() *SeccompProfile

func (*SecurityContext) ProtoMessage 

func (*SecurityContext) ProtoMessage()

func (*SecurityContext) ProtoReflect 

func (x *SecurityContext) ProtoReflect() protoreflect.Message

func (*SecurityContext) Reset 

func (x *SecurityContext) Reset()

func (*SecurityContext) String 

func (x *SecurityContext) String() string

type Service 

type Service struct {

	// Unique identifier for the service
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Human-readable name for the service
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Namespace the service belongs to
	Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Labels for the service
	Labels map[string]string `` /* 139-byte string literal not displayed */
	// Container image for the service
	Image string `protobuf:"bytes,5,opt,name=image,proto3" json:"image,omitempty"`
	// Command to run in the container
	Command string `protobuf:"bytes,6,opt,name=command,proto3" json:"command,omitempty"`
	// Arguments to the command
	Args []string `protobuf:"bytes,7,rep,name=args,proto3" json:"args,omitempty"`
	// Environment variables for the service
	Env map[string]string `` /* 133-byte string literal not displayed */
	// Imported environment variables sources (normalized from spec)
	EnvFrom []*EnvFromSource `protobuf:"bytes,9,rep,name=env_from,json=envFrom,proto3" json:"env_from,omitempty"`
	// Number of instances to run
	Scale int32 `protobuf:"varint,10,opt,name=scale,proto3" json:"scale,omitempty"`
	// Ports exposed by the service
	Ports []*ServicePort `protobuf:"bytes,11,rep,name=ports,proto3" json:"ports,omitempty"`
	// Resource requirements for each instance
	Resources *Resources `protobuf:"bytes,12,opt,name=resources,proto3" json:"resources,omitempty"`
	// Health checks for the service
	Health *HealthCheck `protobuf:"bytes,13,opt,name=health,proto3" json:"health,omitempty"`
	// Status of the service
	Status ServiceStatus `protobuf:"varint,14,opt,name=status,proto3,enum=rune.api.ServiceStatus" json:"status,omitempty"`
	// Runtime for the service ("container" or "process")
	Runtime string `protobuf:"bytes,15,opt,name=runtime,proto3" json:"runtime,omitempty"`
	// Process-specific configuration (when Runtime="process")
	Process *ProcessSpec `protobuf:"bytes,16,opt,name=process,proto3" json:"process,omitempty"`
	// Restart policy for the service
	RestartPolicy RestartPolicy `` /* 130-byte string literal not displayed */
	// Secret mounts
	SecretMounts []*SecretMount `protobuf:"bytes,18,rep,name=secret_mounts,json=secretMounts,proto3" json:"secret_mounts,omitempty"`
	// Configmap mounts
	ConfigmapMounts []*ConfigmapMount `protobuf:"bytes,19,rep,name=configmap_mounts,json=configmapMounts,proto3" json:"configmap_mounts,omitempty"`
	// Metadata for the service
	Metadata *ServiceMetadata `protobuf:"bytes,20,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Dependencies declared by this service (normalized form)
	Dependencies []*DependencyRef `protobuf:"bytes,21,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	// Simple external exposure configuration (MVP)
	Expose *ServiceExpose `protobuf:"bytes,22,opt,name=expose,proto3" json:"expose,omitempty"`
	// ImagePull controls when the runner pulls the container image.
	// Allowed values: "always" (default), "missing", "never".
	ImagePull string `protobuf:"bytes,23,opt,name=image_pull,json=imagePull,proto3" json:"image_pull,omitempty"`
	// StatusReason is a short, machine-friendly slug describing why
	// the service is in its current Status. Examples:
	// "ImagePullBackOff", "ProbeFailed", "OOMKilled", "ScheduleFailed".
	// Empty when status is RUNNING.
	StatusReason string `protobuf:"bytes,24,opt,name=status_reason,json=statusReason,proto3" json:"status_reason,omitempty"`
	// StatusMessage is a single human-readable sentence explaining
	// status_reason, copied verbatim from the worst instance's
	// StatusMessage. Used by the CLI to show "why" without a second
	// command.
	StatusMessage string `protobuf:"bytes,25,opt,name=status_message,json=statusMessage,proto3" json:"status_message,omitempty"`
	// Volume mounts. Exactly one of claim / claim_template
	// is set per mount; binding state lives on the Volume resource itself.
	Volumes []*VolumeMount `protobuf:"bytes,26,rep,name=volumes,proto3" json:"volumes,omitempty"`
	// Init steps run sequentially before each instance's main container
	// (RUNE-121).
	InitSteps []*InitStep `protobuf:"bytes,27,rep,name=init_steps,json=initSteps,proto3" json:"init_steps,omitempty"`
	// SecurityContext applied to the main container. Privileged=true and
	// seccomp=unconfined require the services.privileged policy verb.
	SecurityContext *SecurityContext `protobuf:"bytes,28,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"`
	// contains filtered or unexported fields
}

Service represents a deployable application or workload.

func (*Service) Descriptor deprecated 

func (*Service) Descriptor() ([]byte, []int)

Deprecated: Use Service.ProtoReflect.Descriptor instead.

func (*Service) GetArgs 

func (x *Service) GetArgs() []string

func (*Service) GetCommand 

func (x *Service) GetCommand() string

func (*Service) GetConfigmapMounts 

func (x *Service) GetConfigmapMounts() []*ConfigmapMount

func (*Service) GetDependencies 

func (x *Service) GetDependencies() []*DependencyRef

func (*Service) GetEnv 

func (x *Service) GetEnv() map[string]string

func (*Service) GetEnvFrom 

func (x *Service) GetEnvFrom() []*EnvFromSource

func (*Service) GetExpose 

func (x *Service) GetExpose() *ServiceExpose

func (*Service) GetHealth 

func (x *Service) GetHealth() *HealthCheck

func (*Service) GetId 

func (x *Service) GetId() string

func (*Service) GetImage 

func (x *Service) GetImage() string

func (*Service) GetImagePull 

func (x *Service) GetImagePull() string

func (*Service) GetInitSteps 

func (x *Service) GetInitSteps() []*InitStep

func (*Service) GetLabels 

func (x *Service) GetLabels() map[string]string

func (*Service) GetMetadata 

func (x *Service) GetMetadata() *ServiceMetadata

func (*Service) GetName 

func (x *Service) GetName() string

func (*Service) GetNamespace 

func (x *Service) GetNamespace() string

func (*Service) GetPorts 

func (x *Service) GetPorts() []*ServicePort

func (*Service) GetProcess 

func (x *Service) GetProcess() *ProcessSpec

func (*Service) GetResources 

func (x *Service) GetResources() *Resources

func (*Service) GetRestartPolicy 

func (x *Service) GetRestartPolicy() RestartPolicy

func (*Service) GetRuntime 

func (x *Service) GetRuntime() string

func (*Service) GetScale 

func (x *Service) GetScale() int32

func (*Service) GetSecretMounts 

func (x *Service) GetSecretMounts() []*SecretMount

func (*Service) GetSecurityContext 

func (x *Service) GetSecurityContext() *SecurityContext

func (*Service) GetStatus 

func (x *Service) GetStatus() ServiceStatus

func (*Service) GetStatusMessage 

func (x *Service) GetStatusMessage() string

func (*Service) GetStatusReason 

func (x *Service) GetStatusReason() string

func (*Service) GetVolumes 

func (x *Service) GetVolumes() []*VolumeMount

func (*Service) ProtoMessage 

func (*Service) ProtoMessage()

func (*Service) ProtoReflect 

func (x *Service) ProtoReflect() protoreflect.Message

func (*Service) Reset 

func (x *Service) Reset()

func (*Service) String 

func (x *Service) String() string

type ServiceExpose 

type ServiceExpose struct {

	// Port or port name to expose (must match a declared service port)
	Port string `protobuf:"bytes,1,opt,name=port,proto3" json:"port,omitempty"`
	// Host for the exposed service
	Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
	// Deprecated: host_port is no longer honored. The ingress
	// controller reaches the container by container IP; raw host
	// binds are no longer derived from expose. Field kept for wire
	// compatibility only.
	//
	// Deprecated: Marked as deprecated in pkg/api/proto/common.proto.
	HostPort uint32 `protobuf:"varint,3,opt,name=host_port,json=hostPort,proto3" json:"host_port,omitempty"`
	// Optional path prefix (reserved for future use)
	Path string `protobuf:"bytes,4,opt,name=path,proto3" json:"path,omitempty"`
	// Optional TLS configuration. When omitted, the ingress serves
	// the host on plain HTTP only.
	Tls *ExposeServiceTLS `protobuf:"bytes,5,opt,name=tls,proto3" json:"tls,omitempty"`
	// contains filtered or unexported fields
}

ServiceExpose defines simple external exposure configuration for a service

func (*ServiceExpose) Descriptor deprecated 

func (*ServiceExpose) Descriptor() ([]byte, []int)

Deprecated: Use ServiceExpose.ProtoReflect.Descriptor instead.

func (*ServiceExpose) GetHost 

func (x *ServiceExpose) GetHost() string

func (*ServiceExpose) GetHostPort deprecated 

func (x *ServiceExpose) GetHostPort() uint32

Deprecated: Marked as deprecated in pkg/api/proto/common.proto.

func (*ServiceExpose) GetPath 

func (x *ServiceExpose) GetPath() string

func (*ServiceExpose) GetPort 

func (x *ServiceExpose) GetPort() string

func (*ServiceExpose) GetTls 

func (x *ServiceExpose) GetTls() *ExposeServiceTLS

func (*ServiceExpose) ProtoMessage 

func (*ServiceExpose) ProtoMessage()

func (*ServiceExpose) ProtoReflect 

func (x *ServiceExpose) ProtoReflect() protoreflect.Message

func (*ServiceExpose) Reset 

func (x *ServiceExpose) Reset()

func (*ServiceExpose) String 

func (x *ServiceExpose) String() string

type ServiceMetadata 

type ServiceMetadata struct {

	// Generation number for the service
	Generation int32 `protobuf:"varint,1,opt,name=generation,proto3" json:"generation,omitempty"`
	// Creation timestamp (in RFC 3339 format)
	CreatedAt string `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Last update timestamp (in RFC 3339 format)
	UpdatedAt string `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Last non-zero scale recorded (for restart semantics)
	LastNonZeroScale int32 `protobuf:"varint,4,opt,name=last_non_zero_scale,json=lastNonZeroScale,proto3" json:"last_non_zero_scale,omitempty"`
	// contains filtered or unexported fields
}

ServiceMetadata represents metadata for a service.

func (*ServiceMetadata) Descriptor deprecated 

func (*ServiceMetadata) Descriptor() ([]byte, []int)

Deprecated: Use ServiceMetadata.ProtoReflect.Descriptor instead.

func (*ServiceMetadata) GetCreatedAt 

func (x *ServiceMetadata) GetCreatedAt() string

func (*ServiceMetadata) GetGeneration 

func (x *ServiceMetadata) GetGeneration() int32

func (*ServiceMetadata) GetLastNonZeroScale 

func (x *ServiceMetadata) GetLastNonZeroScale() int32

func (*ServiceMetadata) GetUpdatedAt 

func (x *ServiceMetadata) GetUpdatedAt() string

func (*ServiceMetadata) ProtoMessage 

func (*ServiceMetadata) ProtoMessage()

func (*ServiceMetadata) ProtoReflect 

func (x *ServiceMetadata) ProtoReflect() protoreflect.Message

func (*ServiceMetadata) Reset 

func (x *ServiceMetadata) Reset()

func (*ServiceMetadata) String 

func (x *ServiceMetadata) String() string

type ServicePort 

type ServicePort struct {

	// Name for this port
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Port number
	Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	// Target port (if different from port)
	TargetPort int32 `protobuf:"varint,3,opt,name=target_port,json=targetPort,proto3" json:"target_port,omitempty"`
	// Protocol (default: TCP)
	Protocol string `protobuf:"bytes,4,opt,name=protocol,proto3" json:"protocol,omitempty"`
	// contains filtered or unexported fields
}

ServicePort represents a port exposed by a service.

func (*ServicePort) Descriptor deprecated 

func (*ServicePort) Descriptor() ([]byte, []int)

Deprecated: Use ServicePort.ProtoReflect.Descriptor instead.

func (*ServicePort) GetName 

func (x *ServicePort) GetName() string

func (*ServicePort) GetPort 

func (x *ServicePort) GetPort() int32

func (*ServicePort) GetProtocol 

func (x *ServicePort) GetProtocol() string

func (*ServicePort) GetTargetPort 

func (x *ServicePort) GetTargetPort() int32

func (*ServicePort) ProtoMessage 

func (*ServicePort) ProtoMessage()

func (*ServicePort) ProtoReflect 

func (x *ServicePort) ProtoReflect() protoreflect.Message

func (*ServicePort) Reset 

func (x *ServicePort) Reset()

func (*ServicePort) String 

func (x *ServicePort) String() string

type ServiceResponse 

type ServiceResponse struct {

	// The service, if successful
	Service *Service `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

ServiceResponse returns a service or status.

func (*ServiceResponse) Descriptor deprecated 

func (*ServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use ServiceResponse.ProtoReflect.Descriptor instead.

func (*ServiceResponse) GetService 

func (x *ServiceResponse) GetService() *Service

func (*ServiceResponse) GetStatus 

func (x *ServiceResponse) GetStatus() *Status

func (*ServiceResponse) ProtoMessage 

func (*ServiceResponse) ProtoMessage()

func (*ServiceResponse) ProtoReflect 

func (x *ServiceResponse) ProtoReflect() protoreflect.Message

func (*ServiceResponse) Reset 

func (x *ServiceResponse) Reset()

func (*ServiceResponse) String 

func (x *ServiceResponse) String() string

type ServiceServiceClient 

type ServiceServiceClient interface {
	// CreateService creates a new service.
	CreateService(ctx context.Context, in *CreateServiceRequest, opts ...grpc.CallOption) (*ServiceResponse, error)
	// GetService retrieves a service by name.
	GetService(ctx context.Context, in *GetServiceRequest, opts ...grpc.CallOption) (*ServiceResponse, error)
	// ListServices lists services with optional filtering.
	ListServices(ctx context.Context, in *ListServicesRequest, opts ...grpc.CallOption) (*ListServicesResponse, error)
	// WatchServices watches services for changes.
	WatchServices(ctx context.Context, in *WatchServicesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchServicesResponse], error)
	// UpdateService updates an existing service.
	UpdateService(ctx context.Context, in *UpdateServiceRequest, opts ...grpc.CallOption) (*ServiceResponse, error)
	// DeleteService removes a service.
	DeleteService(ctx context.Context, in *DeleteServiceRequest, opts ...grpc.CallOption) (*DeleteServiceResponse, error)
	// GetDeletionStatus gets the status of a deletion operation
	GetDeletionStatus(ctx context.Context, in *GetDeletionStatusRequest, opts ...grpc.CallOption) (*GetDeletionStatusResponse, error)
	// ListDeletionOperations lists all deletion operations
	ListDeletionOperations(ctx context.Context, in *ListDeletionOperationsRequest, opts ...grpc.CallOption) (*ListDeletionOperationsResponse, error)
	// ScaleService changes the scale of a service.
	ScaleService(ctx context.Context, in *ScaleServiceRequest, opts ...grpc.CallOption) (*ServiceResponse, error)
	// WatchScaling watches the scaling progress of a service.
	WatchScaling(ctx context.Context, in *WatchScalingRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ScalingStatusResponse], error)
	// ListInstances lists instances for a service.
	ListInstances(ctx context.Context, in *ListInstancesRequest, opts ...grpc.CallOption) (*ListInstancesResponse, error)
}

ServiceServiceClient is the client API for ServiceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

ServiceService manages services within the platform.

func NewServiceServiceClient 

func NewServiceServiceClient(cc grpc.ClientConnInterface) ServiceServiceClient

type ServiceServiceServer 

type ServiceServiceServer interface {
	// CreateService creates a new service.
	CreateService(context.Context, *CreateServiceRequest) (*ServiceResponse, error)
	// GetService retrieves a service by name.
	GetService(context.Context, *GetServiceRequest) (*ServiceResponse, error)
	// ListServices lists services with optional filtering.
	ListServices(context.Context, *ListServicesRequest) (*ListServicesResponse, error)
	// WatchServices watches services for changes.
	WatchServices(*WatchServicesRequest, grpc.ServerStreamingServer[WatchServicesResponse]) error
	// UpdateService updates an existing service.
	UpdateService(context.Context, *UpdateServiceRequest) (*ServiceResponse, error)
	// DeleteService removes a service.
	DeleteService(context.Context, *DeleteServiceRequest) (*DeleteServiceResponse, error)
	// GetDeletionStatus gets the status of a deletion operation
	GetDeletionStatus(context.Context, *GetDeletionStatusRequest) (*GetDeletionStatusResponse, error)
	// ListDeletionOperations lists all deletion operations
	ListDeletionOperations(context.Context, *ListDeletionOperationsRequest) (*ListDeletionOperationsResponse, error)
	// ScaleService changes the scale of a service.
	ScaleService(context.Context, *ScaleServiceRequest) (*ServiceResponse, error)
	// WatchScaling watches the scaling progress of a service.
	WatchScaling(*WatchScalingRequest, grpc.ServerStreamingServer[ScalingStatusResponse]) error
	// ListInstances lists instances for a service.
	ListInstances(context.Context, *ListInstancesRequest) (*ListInstancesResponse, error)
	// contains filtered or unexported methods
}

ServiceServiceServer is the server API for ServiceService service. All implementations must embed UnimplementedServiceServiceServer for forward compatibility.

ServiceService manages services within the platform.

type ServiceService_WatchScalingClient 

type ServiceService_WatchScalingClient = grpc.ServerStreamingClient[ScalingStatusResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ServiceService_WatchScalingServer 

type ServiceService_WatchScalingServer = grpc.ServerStreamingServer[ScalingStatusResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ServiceService_WatchServicesClient 

type ServiceService_WatchServicesClient = grpc.ServerStreamingClient[WatchServicesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ServiceService_WatchServicesServer 

type ServiceService_WatchServicesServer = grpc.ServerStreamingServer[WatchServicesResponse]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ServiceStatus 

type ServiceStatus int32

ServiceStatus represents the current status of a service. 

const (
	ServiceStatus_SERVICE_STATUS_UNSPECIFIED ServiceStatus = 0
	ServiceStatus_SERVICE_STATUS_PENDING     ServiceStatus = 1 // Service is being created
	ServiceStatus_SERVICE_STATUS_RUNNING     ServiceStatus = 2 // Service is running
	ServiceStatus_SERVICE_STATUS_UPDATING    ServiceStatus = 3 // Service is being updated
	ServiceStatus_SERVICE_STATUS_FAILED      ServiceStatus = 4 // Service failed to deploy or run
)

func (ServiceStatus) Descriptor 

func (ServiceStatus) Descriptor() protoreflect.EnumDescriptor

func (ServiceStatus) Enum 

func (x ServiceStatus) Enum() *ServiceStatus

func (ServiceStatus) EnumDescriptor deprecated 

func (ServiceStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use ServiceStatus.Descriptor instead.

func (ServiceStatus) Number 

func (x ServiceStatus) Number() protoreflect.EnumNumber

func (ServiceStatus) String 

func (x ServiceStatus) String() string

func (ServiceStatus) Type 

func (ServiceStatus) Type() protoreflect.EnumType

type Signal 

type Signal struct {

	// Signal name (e.g., "SIGINT", "SIGTERM")
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Signal represents a signal to send to the process.

func (*Signal) Descriptor deprecated 

func (*Signal) Descriptor() ([]byte, []int)

Deprecated: Use Signal.ProtoReflect.Descriptor instead.

func (*Signal) GetName 

func (x *Signal) GetName() string

func (*Signal) ProtoMessage 

func (*Signal) ProtoMessage()

func (*Signal) ProtoReflect 

func (x *Signal) ProtoReflect() protoreflect.Message

func (*Signal) Reset 

func (x *Signal) Reset()

func (*Signal) String 

func (x *Signal) String() string

type Snapshot 

type Snapshot struct {
	Id        string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name      string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string            `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Labels    map[string]string `` /* 139-byte string literal not displayed */
	// SourceVolume is the bare name of the Volume in the same namespace.
	SourceVolume string `protobuf:"bytes,5,opt,name=source_volume,json=sourceVolume,proto3" json:"source_volume,omitempty"`
	// Driver records which driver took the snapshot — needed at restore
	// time to route the call.
	Driver string `protobuf:"bytes,6,opt,name=driver,proto3" json:"driver,omitempty"`
	// Handle is the driver-populated opaque snapshot identifier.
	Handle    string `protobuf:"bytes,7,opt,name=handle,proto3" json:"handle,omitempty"`
	SizeBytes int64  `protobuf:"varint,8,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
	// Scheduled is true when the snapshot was created by a SnapshotSchedule
	// rather than an explicit create call.
	Scheduled bool `protobuf:"varint,9,opt,name=scheduled,proto3" json:"scheduled,omitempty"`
	// Phase is one of: Pending, Creating, Ready, Deleting, Failed.
	Phase     string `protobuf:"bytes,10,opt,name=phase,proto3" json:"phase,omitempty"`
	Reason    string `protobuf:"bytes,11,opt,name=reason,proto3" json:"reason,omitempty"`
	Message   string `protobuf:"bytes,12,opt,name=message,proto3" json:"message,omitempty"`
	CreatedAt string `protobuf:"bytes,13,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt string `protobuf:"bytes,14,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

Snapshot mirrors pkg/types.Snapshot. Namespace-scoped point-in-time copy of a Volume.

func (*Snapshot) Descriptor deprecated 

func (*Snapshot) Descriptor() ([]byte, []int)

Deprecated: Use Snapshot.ProtoReflect.Descriptor instead.

func (*Snapshot) GetCreatedAt 

func (x *Snapshot) GetCreatedAt() string

func (*Snapshot) GetDriver 

func (x *Snapshot) GetDriver() string

func (*Snapshot) GetHandle 

func (x *Snapshot) GetHandle() string

func (*Snapshot) GetId 

func (x *Snapshot) GetId() string

func (*Snapshot) GetLabels 

func (x *Snapshot) GetLabels() map[string]string

func (*Snapshot) GetMessage 

func (x *Snapshot) GetMessage() string

func (*Snapshot) GetName 

func (x *Snapshot) GetName() string

func (*Snapshot) GetNamespace 

func (x *Snapshot) GetNamespace() string

func (*Snapshot) GetPhase 

func (x *Snapshot) GetPhase() string

func (*Snapshot) GetReason 

func (x *Snapshot) GetReason() string

func (*Snapshot) GetScheduled 

func (x *Snapshot) GetScheduled() bool

func (*Snapshot) GetSizeBytes 

func (x *Snapshot) GetSizeBytes() int64

func (*Snapshot) GetSourceVolume 

func (x *Snapshot) GetSourceVolume() string

func (*Snapshot) GetUpdatedAt 

func (x *Snapshot) GetUpdatedAt() string

func (*Snapshot) ProtoMessage 

func (*Snapshot) ProtoMessage()

func (*Snapshot) ProtoReflect 

func (x *Snapshot) ProtoReflect() protoreflect.Message

func (*Snapshot) Reset 

func (x *Snapshot) Reset()

func (*Snapshot) String 

func (x *Snapshot) String() string

type SnapshotResponse 

type SnapshotResponse struct {
	Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	Status   *Status   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*SnapshotResponse) Descriptor deprecated 

func (*SnapshotResponse) Descriptor() ([]byte, []int)

Deprecated: Use SnapshotResponse.ProtoReflect.Descriptor instead.

func (*SnapshotResponse) GetSnapshot 

func (x *SnapshotResponse) GetSnapshot() *Snapshot

func (*SnapshotResponse) GetStatus 

func (x *SnapshotResponse) GetStatus() *Status

func (*SnapshotResponse) ProtoMessage 

func (*SnapshotResponse) ProtoMessage()

func (*SnapshotResponse) ProtoReflect 

func (x *SnapshotResponse) ProtoReflect() protoreflect.Message

func (*SnapshotResponse) Reset 

func (x *SnapshotResponse) Reset()

func (*SnapshotResponse) String 

func (x *SnapshotResponse) String() string

type SnapshotSchedule 

type SnapshotSchedule struct {
	Cron      string `protobuf:"bytes,1,opt,name=cron,proto3" json:"cron,omitempty"`
	Retention int32  `protobuf:"varint,2,opt,name=retention,proto3" json:"retention,omitempty"`
	// contains filtered or unexported fields
}

SnapshotSchedule mirrors pkg/types.SnapshotSchedule.

func (*SnapshotSchedule) Descriptor deprecated 

func (*SnapshotSchedule) Descriptor() ([]byte, []int)

Deprecated: Use SnapshotSchedule.ProtoReflect.Descriptor instead.

func (*SnapshotSchedule) GetCron 

func (x *SnapshotSchedule) GetCron() string

func (*SnapshotSchedule) GetRetention 

func (x *SnapshotSchedule) GetRetention() int32

func (*SnapshotSchedule) ProtoMessage 

func (*SnapshotSchedule) ProtoMessage()

func (*SnapshotSchedule) ProtoReflect 

func (x *SnapshotSchedule) ProtoReflect() protoreflect.Message

func (*SnapshotSchedule) Reset 

func (x *SnapshotSchedule) Reset()

func (*SnapshotSchedule) String 

func (x *SnapshotSchedule) String() string

type SnapshotServiceClient 

type SnapshotServiceClient interface {
	CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*SnapshotResponse, error)
	GetSnapshot(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*SnapshotResponse, error)
	DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*Status, error)
	ListSnapshots(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
	// RestoreVolume provisions a new Volume from this Snapshot. The
	// returned Volume starts in Pending; the volume controller drives it
	// to Available once the driver completes RestoreFromSnapshot.
	RestoreVolume(ctx context.Context, in *RestoreVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
}

SnapshotServiceClient is the client API for SnapshotService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewSnapshotServiceClient 

func NewSnapshotServiceClient(cc grpc.ClientConnInterface) SnapshotServiceClient

type SnapshotServiceServer 

type SnapshotServiceServer interface {
	CreateSnapshot(context.Context, *CreateSnapshotRequest) (*SnapshotResponse, error)
	GetSnapshot(context.Context, *GetSnapshotRequest) (*SnapshotResponse, error)
	DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*Status, error)
	ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
	// RestoreVolume provisions a new Volume from this Snapshot. The
	// returned Volume starts in Pending; the volume controller drives it
	// to Available once the driver completes RestoreFromSnapshot.
	RestoreVolume(context.Context, *RestoreVolumeRequest) (*VolumeResponse, error)
	// contains filtered or unexported methods
}

SnapshotServiceServer is the server API for SnapshotService service. All implementations must embed UnimplementedSnapshotServiceServer for forward compatibility.

type Status 

type Status struct {

	// Status code
	Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// Status message
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// Details about the status
	Details []string `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
	// contains filtered or unexported fields
}

Common status message returned by many operations

func (*Status) Descriptor deprecated 

func (*Status) Descriptor() ([]byte, []int)

Deprecated: Use Status.ProtoReflect.Descriptor instead.

func (*Status) GetCode 

func (x *Status) GetCode() int32

func (*Status) GetDetails 

func (x *Status) GetDetails() []string

func (*Status) GetMessage 

func (x *Status) GetMessage() string

func (*Status) ProtoMessage 

func (*Status) ProtoMessage()

func (*Status) ProtoReflect 

func (x *Status) ProtoReflect() protoreflect.Message

func (*Status) Reset 

func (x *Status) Reset()

func (*Status) String 

func (x *Status) String() string

type StorageClass 

type StorageClass struct {
	Id         string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name       string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Driver     string            `protobuf:"bytes,3,opt,name=driver,proto3" json:"driver,omitempty"`
	Parameters map[string]string `` /* 147-byte string literal not displayed */
	// ReclaimPolicy is one of: "retain", "delete".
	ReclaimPolicy     string              `protobuf:"bytes,5,opt,name=reclaim_policy,json=reclaimPolicy,proto3" json:"reclaim_policy,omitempty"`
	AllowedTopologies []*TopologySelector `protobuf:"bytes,6,rep,name=allowed_topologies,json=allowedTopologies,proto3" json:"allowed_topologies,omitempty"`
	Default           bool                `protobuf:"varint,7,opt,name=default,proto3" json:"default,omitempty"`
	Labels            map[string]string   `` /* 139-byte string literal not displayed */
	CreatedAt         string              `protobuf:"bytes,9,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt         string              `protobuf:"bytes,10,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

StorageClass mirrors pkg/types.StorageClass. Cluster-scoped (no namespace).

func (*StorageClass) Descriptor deprecated 

func (*StorageClass) Descriptor() ([]byte, []int)

Deprecated: Use StorageClass.ProtoReflect.Descriptor instead.

func (*StorageClass) GetAllowedTopologies 

func (x *StorageClass) GetAllowedTopologies() []*TopologySelector

func (*StorageClass) GetCreatedAt 

func (x *StorageClass) GetCreatedAt() string

func (*StorageClass) GetDefault 

func (x *StorageClass) GetDefault() bool

func (*StorageClass) GetDriver 

func (x *StorageClass) GetDriver() string

func (*StorageClass) GetId 

func (x *StorageClass) GetId() string

func (*StorageClass) GetLabels 

func (x *StorageClass) GetLabels() map[string]string

func (*StorageClass) GetName 

func (x *StorageClass) GetName() string

func (*StorageClass) GetParameters 

func (x *StorageClass) GetParameters() map[string]string

func (*StorageClass) GetReclaimPolicy 

func (x *StorageClass) GetReclaimPolicy() string

func (*StorageClass) GetUpdatedAt 

func (x *StorageClass) GetUpdatedAt() string

func (*StorageClass) ProtoMessage 

func (*StorageClass) ProtoMessage()

func (*StorageClass) ProtoReflect 

func (x *StorageClass) ProtoReflect() protoreflect.Message

func (*StorageClass) Reset 

func (x *StorageClass) Reset()

func (*StorageClass) String 

func (x *StorageClass) String() string

type StorageClassResponse 

type StorageClassResponse struct {
	StorageClass *StorageClass `protobuf:"bytes,1,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"`
	Status       *Status       `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*StorageClassResponse) Descriptor deprecated 

func (*StorageClassResponse) Descriptor() ([]byte, []int)

Deprecated: Use StorageClassResponse.ProtoReflect.Descriptor instead.

func (*StorageClassResponse) GetStatus 

func (x *StorageClassResponse) GetStatus() *Status

func (*StorageClassResponse) GetStorageClass 

func (x *StorageClassResponse) GetStorageClass() *StorageClass

func (*StorageClassResponse) ProtoMessage 

func (*StorageClassResponse) ProtoMessage()

func (*StorageClassResponse) ProtoReflect 

func (x *StorageClassResponse) ProtoReflect() protoreflect.Message

func (*StorageClassResponse) Reset 

func (x *StorageClassResponse) Reset()

func (*StorageClassResponse) String 

func (x *StorageClassResponse) String() string

type StorageClassServiceClient 

type StorageClassServiceClient interface {
	CreateStorageClass(ctx context.Context, in *CreateStorageClassRequest, opts ...grpc.CallOption) (*StorageClassResponse, error)
	GetStorageClass(ctx context.Context, in *GetStorageClassRequest, opts ...grpc.CallOption) (*StorageClassResponse, error)
	UpdateStorageClass(ctx context.Context, in *UpdateStorageClassRequest, opts ...grpc.CallOption) (*StorageClassResponse, error)
	DeleteStorageClass(ctx context.Context, in *DeleteStorageClassRequest, opts ...grpc.CallOption) (*Status, error)
	ListStorageClasses(ctx context.Context, in *ListStorageClassesRequest, opts ...grpc.CallOption) (*ListStorageClassesResponse, error)
}

StorageClassServiceClient is the client API for StorageClassService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewStorageClassServiceClient 

func NewStorageClassServiceClient(cc grpc.ClientConnInterface) StorageClassServiceClient

type StorageClassServiceServer 

type StorageClassServiceServer interface {
	CreateStorageClass(context.Context, *CreateStorageClassRequest) (*StorageClassResponse, error)
	GetStorageClass(context.Context, *GetStorageClassRequest) (*StorageClassResponse, error)
	UpdateStorageClass(context.Context, *UpdateStorageClassRequest) (*StorageClassResponse, error)
	DeleteStorageClass(context.Context, *DeleteStorageClassRequest) (*Status, error)
	ListStorageClasses(context.Context, *ListStorageClassesRequest) (*ListStorageClassesResponse, error)
	// contains filtered or unexported methods
}

StorageClassServiceServer is the server API for StorageClassService service. All implementations must embed UnimplementedStorageClassServiceServer for forward compatibility.

type Subject 

type Subject struct {
	Id       string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Kind     string   `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind,omitempty"` // user|service
	Name     string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Email    string   `protobuf:"bytes,4,opt,name=email,proto3" json:"email,omitempty"`       // optional for users
	Policies []string `protobuf:"bytes,5,rep,name=policies,proto3" json:"policies,omitempty"` // names or ids
	// contains filtered or unexported fields
}

Subjects represent principals (user or service account)

func (*Subject) Descriptor deprecated 

func (*Subject) Descriptor() ([]byte, []int)

Deprecated: Use Subject.ProtoReflect.Descriptor instead.

func (*Subject) GetEmail 

func (x *Subject) GetEmail() string

func (*Subject) GetId 

func (x *Subject) GetId() string

func (*Subject) GetKind 

func (x *Subject) GetKind() string

func (*Subject) GetName 

func (x *Subject) GetName() string

func (*Subject) GetPolicies 

func (x *Subject) GetPolicies() []string

func (*Subject) ProtoMessage 

func (*Subject) ProtoMessage()

func (*Subject) ProtoReflect 

func (x *Subject) ProtoReflect() protoreflect.Message

func (*Subject) Reset 

func (x *Subject) Reset()

func (*Subject) String 

func (x *Subject) String() string

type SubscribeRequest 

type SubscribeRequest struct {

	// Resume from this seq. The server will deliver events with
	// seq > from_seq. Use 0 to receive everything from the beginning of
	// retention.
	FromSeq uint64 `protobuf:"varint,1,opt,name=from_seq,json=fromSeq,proto3" json:"from_seq,omitempty"`
	// Optional: client identifier for server-side logging / metrics.
	// Not authenticated; use the gRPC auth metadata for that.
	ClientId string `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	// contains filtered or unexported fields
}

func (*SubscribeRequest) Descriptor deprecated 

func (*SubscribeRequest) Descriptor() ([]byte, []int)

Deprecated: Use SubscribeRequest.ProtoReflect.Descriptor instead.

func (*SubscribeRequest) GetClientId 

func (x *SubscribeRequest) GetClientId() string

func (*SubscribeRequest) GetFromSeq 

func (x *SubscribeRequest) GetFromSeq() uint64

func (*SubscribeRequest) ProtoMessage 

func (*SubscribeRequest) ProtoMessage()

func (*SubscribeRequest) ProtoReflect 

func (x *SubscribeRequest) ProtoReflect() protoreflect.Message

func (*SubscribeRequest) Reset 

func (x *SubscribeRequest) Reset()

func (*SubscribeRequest) String 

func (x *SubscribeRequest) String() string

type TerminalSize 

type TerminalSize struct {

	// Width in characters
	Width uint32 `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
	// Height in characters
	Height uint32 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	// contains filtered or unexported fields
}

TerminalSize represents the size of a terminal.

func (*TerminalSize) Descriptor deprecated 

func (*TerminalSize) Descriptor() ([]byte, []int)

Deprecated: Use TerminalSize.ProtoReflect.Descriptor instead.

func (*TerminalSize) GetHeight 

func (x *TerminalSize) GetHeight() uint32

func (*TerminalSize) GetWidth 

func (x *TerminalSize) GetWidth() uint32

func (*TerminalSize) ProtoMessage 

func (*TerminalSize) ProtoMessage()

func (*TerminalSize) ProtoReflect 

func (x *TerminalSize) ProtoReflect() protoreflect.Message

func (*TerminalSize) Reset 

func (x *TerminalSize) Reset()

func (*TerminalSize) String 

func (x *TerminalSize) String() string

type TestRegistryRequest 

type TestRegistryRequest struct {
	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`                         // registry name to test
	ImageRef string `protobuf:"bytes,2,opt,name=image_ref,json=imageRef,proto3" json:"image_ref,omitempty"` // optional image to attempt auth against
	// contains filtered or unexported fields
}

func (*TestRegistryRequest) Descriptor deprecated 

func (*TestRegistryRequest) Descriptor() ([]byte, []int)

Deprecated: Use TestRegistryRequest.ProtoReflect.Descriptor instead.

func (*TestRegistryRequest) GetImageRef 

func (x *TestRegistryRequest) GetImageRef() string

func (*TestRegistryRequest) GetName 

func (x *TestRegistryRequest) GetName() string

func (*TestRegistryRequest) ProtoMessage 

func (*TestRegistryRequest) ProtoMessage()

func (*TestRegistryRequest) ProtoReflect 

func (x *TestRegistryRequest) ProtoReflect() protoreflect.Message

func (*TestRegistryRequest) Reset 

func (x *TestRegistryRequest) Reset()

func (*TestRegistryRequest) String 

func (x *TestRegistryRequest) String() string

type TestRegistryResponse 

type TestRegistryResponse struct {
	Ok      bool   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

func (*TestRegistryResponse) Descriptor deprecated 

func (*TestRegistryResponse) Descriptor() ([]byte, []int)

Deprecated: Use TestRegistryResponse.ProtoReflect.Descriptor instead.

func (*TestRegistryResponse) GetMessage 

func (x *TestRegistryResponse) GetMessage() string

func (*TestRegistryResponse) GetOk 

func (x *TestRegistryResponse) GetOk() bool

func (*TestRegistryResponse) ProtoMessage 

func (*TestRegistryResponse) ProtoMessage()

func (*TestRegistryResponse) ProtoReflect 

func (x *TestRegistryResponse) ProtoReflect() protoreflect.Message

func (*TestRegistryResponse) Reset 

func (x *TestRegistryResponse) Reset()

func (*TestRegistryResponse) String 

func (x *TestRegistryResponse) String() string

type TokenInfo 

type TokenInfo struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	SubjectId   string `protobuf:"bytes,3,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`
	SubjectType string `protobuf:"bytes,4,opt,name=subject_type,json=subjectType,proto3" json:"subject_type,omitempty"` // user|service
	Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	IssuedAt    int64  `protobuf:"varint,6,opt,name=issued_at,json=issuedAt,proto3" json:"issued_at,omitempty"`    // unix seconds
	ExpiresAt   int64  `protobuf:"varint,7,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` // unix seconds (0 means none)
	Revoked     bool   `protobuf:"varint,8,opt,name=revoked,proto3" json:"revoked,omitempty"`
	// contains filtered or unexported fields
}

Token listing (admin-only)

func (*TokenInfo) Descriptor deprecated 

func (*TokenInfo) Descriptor() ([]byte, []int)

Deprecated: Use TokenInfo.ProtoReflect.Descriptor instead.

func (*TokenInfo) GetDescription 

func (x *TokenInfo) GetDescription() string

func (*TokenInfo) GetExpiresAt 

func (x *TokenInfo) GetExpiresAt() int64

func (*TokenInfo) GetId 

func (x *TokenInfo) GetId() string

func (*TokenInfo) GetIssuedAt 

func (x *TokenInfo) GetIssuedAt() int64

func (*TokenInfo) GetName 

func (x *TokenInfo) GetName() string

func (*TokenInfo) GetRevoked 

func (x *TokenInfo) GetRevoked() bool

func (*TokenInfo) GetSubjectId 

func (x *TokenInfo) GetSubjectId() string

func (*TokenInfo) GetSubjectType 

func (x *TokenInfo) GetSubjectType() string

func (*TokenInfo) ProtoMessage 

func (*TokenInfo) ProtoMessage()

func (*TokenInfo) ProtoReflect 

func (x *TokenInfo) ProtoReflect() protoreflect.Message

func (*TokenInfo) Reset 

func (x *TokenInfo) Reset()

func (*TokenInfo) String 

func (x *TokenInfo) String() string

type TokenListRequest 

type TokenListRequest struct {
	// contains filtered or unexported fields
}

func (*TokenListRequest) Descriptor deprecated 

func (*TokenListRequest) Descriptor() ([]byte, []int)

Deprecated: Use TokenListRequest.ProtoReflect.Descriptor instead.

func (*TokenListRequest) ProtoMessage 

func (*TokenListRequest) ProtoMessage()

func (*TokenListRequest) ProtoReflect 

func (x *TokenListRequest) ProtoReflect() protoreflect.Message

func (*TokenListRequest) Reset 

func (x *TokenListRequest) Reset()

func (*TokenListRequest) String 

func (x *TokenListRequest) String() string

type TokenListResponse 

type TokenListResponse struct {
	Tokens []*TokenInfo `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"`
	// contains filtered or unexported fields
}

func (*TokenListResponse) Descriptor deprecated 

func (*TokenListResponse) Descriptor() ([]byte, []int)

Deprecated: Use TokenListResponse.ProtoReflect.Descriptor instead.

func (*TokenListResponse) GetTokens 

func (x *TokenListResponse) GetTokens() []*TokenInfo

func (*TokenListResponse) ProtoMessage 

func (*TokenListResponse) ProtoMessage()

func (*TokenListResponse) ProtoReflect 

func (x *TokenListResponse) ProtoReflect() protoreflect.Message

func (*TokenListResponse) Reset 

func (x *TokenListResponse) Reset()

func (*TokenListResponse) String 

func (x *TokenListResponse) String() string

type TopologyMatchExpression 

type TopologyMatchExpression struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Operator is one of: In, NotIn, Exists, DoesNotExist.
	Operator string   `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
	Values   []string `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

TopologyMatchExpression mirrors pkg/types.TopologyMatchExpression.

func (*TopologyMatchExpression) Descriptor deprecated 

func (*TopologyMatchExpression) Descriptor() ([]byte, []int)

Deprecated: Use TopologyMatchExpression.ProtoReflect.Descriptor instead.

func (*TopologyMatchExpression) GetKey 

func (x *TopologyMatchExpression) GetKey() string

func (*TopologyMatchExpression) GetOperator 

func (x *TopologyMatchExpression) GetOperator() string

func (*TopologyMatchExpression) GetValues 

func (x *TopologyMatchExpression) GetValues() []string

func (*TopologyMatchExpression) ProtoMessage 

func (*TopologyMatchExpression) ProtoMessage()

func (*TopologyMatchExpression) ProtoReflect 

func (x *TopologyMatchExpression) ProtoReflect() protoreflect.Message

func (*TopologyMatchExpression) Reset 

func (x *TopologyMatchExpression) Reset()

func (*TopologyMatchExpression) String 

func (x *TopologyMatchExpression) String() string

type TopologySelector 

type TopologySelector struct {
	MatchLabels      map[string]string          `` /* 168-byte string literal not displayed */
	MatchExpressions []*TopologyMatchExpression `protobuf:"bytes,2,rep,name=match_expressions,json=matchExpressions,proto3" json:"match_expressions,omitempty"`
	// contains filtered or unexported fields
}

TopologySelector mirrors pkg/types.TopologySelector.

func (*TopologySelector) Descriptor deprecated 

func (*TopologySelector) Descriptor() ([]byte, []int)

Deprecated: Use TopologySelector.ProtoReflect.Descriptor instead.

func (*TopologySelector) GetMatchExpressions 

func (x *TopologySelector) GetMatchExpressions() []*TopologyMatchExpression

func (*TopologySelector) GetMatchLabels 

func (x *TopologySelector) GetMatchLabels() map[string]string

func (*TopologySelector) ProtoMessage 

func (*TopologySelector) ProtoMessage()

func (*TopologySelector) ProtoReflect 

func (x *TopologySelector) ProtoReflect() protoreflect.Message

func (*TopologySelector) Reset 

func (x *TopologySelector) Reset()

func (*TopologySelector) String 

func (x *TopologySelector) String() string

type UnimplementedAdminServiceServer 

type UnimplementedAdminServiceServer struct{}

UnimplementedAdminServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedAdminServiceServer) AddRegistry 

func (UnimplementedAdminServiceServer) AddRegistry(context.Context, *AddRegistryRequest) (*AddRegistryResponse, error)

func (UnimplementedAdminServiceServer) AdminBootstrap 

func (UnimplementedAdminServiceServer) AdminBootstrap(context.Context, *AdminBootstrapRequest) (*AdminBootstrapResponse, error)

func (UnimplementedAdminServiceServer) BootstrapAuth 

func (UnimplementedAdminServiceServer) BootstrapAuth(context.Context, *BootstrapAuthRequest) (*BootstrapAuthResponse, error)

func (UnimplementedAdminServiceServer) GetRegistry 

func (UnimplementedAdminServiceServer) GetRegistry(context.Context, *GetRegistryRequest) (*GetRegistryResponse, error)

func (UnimplementedAdminServiceServer) ListRegistries 

func (UnimplementedAdminServiceServer) ListRegistries(context.Context, *ListRegistriesRequest) (*ListRegistriesResponse, error)

func (UnimplementedAdminServiceServer) NetworkStatus 

func (UnimplementedAdminServiceServer) NetworkStatus(context.Context, *NetworkStatusRequest) (*NetworkStatusResponse, error)

func (UnimplementedAdminServiceServer) PolicyAttachToSubject 

func (UnimplementedAdminServiceServer) PolicyAttachToSubject(context.Context, *PolicyAttachToSubjectRequest) (*PolicyAttachToSubjectResponse, error)

func (UnimplementedAdminServiceServer) PolicyCreate 

func (UnimplementedAdminServiceServer) PolicyCreate(context.Context, *PolicyCreateRequest) (*PolicyCreateResponse, error)

func (UnimplementedAdminServiceServer) PolicyDelete 

func (UnimplementedAdminServiceServer) PolicyDelete(context.Context, *PolicyDeleteRequest) (*PolicyDeleteResponse, error)

func (UnimplementedAdminServiceServer) PolicyDetachFromSubject 

func (UnimplementedAdminServiceServer) PolicyDetachFromSubject(context.Context, *PolicyDetachFromSubjectRequest) (*PolicyDetachFromSubjectResponse, error)

func (UnimplementedAdminServiceServer) PolicyGet 

func (UnimplementedAdminServiceServer) PolicyGet(context.Context, *PolicyGetRequest) (*PolicyGetResponse, error)

func (UnimplementedAdminServiceServer) PolicyList 

func (UnimplementedAdminServiceServer) PolicyList(context.Context, *PolicyListRequest) (*PolicyListResponse, error)

func (UnimplementedAdminServiceServer) PolicyUpdate 

func (UnimplementedAdminServiceServer) PolicyUpdate(context.Context, *PolicyUpdateRequest) (*PolicyUpdateResponse, error)

func (UnimplementedAdminServiceServer) RegistriesStatus 

func (UnimplementedAdminServiceServer) RegistriesStatus(context.Context, *RegistriesStatusRequest) (*RegistriesStatusResponse, error)

func (UnimplementedAdminServiceServer) RemoveRegistry 

func (UnimplementedAdminServiceServer) RemoveRegistry(context.Context, *RemoveRegistryRequest) (*RemoveRegistryResponse, error)

func (UnimplementedAdminServiceServer) TestRegistry 

func (UnimplementedAdminServiceServer) TestRegistry(context.Context, *TestRegistryRequest) (*TestRegistryResponse, error)

func (UnimplementedAdminServiceServer) TokenList 

func (UnimplementedAdminServiceServer) TokenList(context.Context, *TokenListRequest) (*TokenListResponse, error)

func (UnimplementedAdminServiceServer) UpdateRegistry 

func (UnimplementedAdminServiceServer) UpdateRegistry(context.Context, *UpdateRegistryRequest) (*UpdateRegistryResponse, error)

func (UnimplementedAdminServiceServer) UserCreate 

func (UnimplementedAdminServiceServer) UserCreate(context.Context, *UserCreateRequest) (*UserCreateResponse, error)

func (UnimplementedAdminServiceServer) UserList 

func (UnimplementedAdminServiceServer) UserList(context.Context, *UserListRequest) (*UserListResponse, error)

type UnimplementedAuditServiceServer 

type UnimplementedAuditServiceServer struct{}

UnimplementedAuditServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedAuditServiceServer) ListAuditEvents 

func (UnimplementedAuditServiceServer) ListAuditEvents(context.Context, *ListAuditEventsRequest) (*ListAuditEventsResponse, error)

type UnimplementedAuthServiceServer 

type UnimplementedAuthServiceServer struct{}

UnimplementedAuthServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedAuthServiceServer) CreateToken 

func (UnimplementedAuthServiceServer) CreateToken(context.Context, *CreateTokenRequest) (*CreateTokenResponse, error)

func (UnimplementedAuthServiceServer) RevokeToken 

func (UnimplementedAuthServiceServer) RevokeToken(context.Context, *RevokeTokenRequest) (*RevokeTokenResponse, error)

func (UnimplementedAuthServiceServer) WhoAmI 

func (UnimplementedAuthServiceServer) WhoAmI(context.Context, *WhoAmIRequest) (*WhoAmIResponse, error)

type UnimplementedConfigmapServiceServer 

type UnimplementedConfigmapServiceServer struct{}

UnimplementedConfigmapServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedConfigmapServiceServer) CreateConfigmap 

func (UnimplementedConfigmapServiceServer) CreateConfigmap(context.Context, *CreateConfigmapRequest) (*ConfigmapResponse, error)

func (UnimplementedConfigmapServiceServer) DeleteConfigmap 

func (UnimplementedConfigmapServiceServer) DeleteConfigmap(context.Context, *DeleteConfigmapRequest) (*Status, error)

func (UnimplementedConfigmapServiceServer) GetConfigmap 

func (UnimplementedConfigmapServiceServer) GetConfigmap(context.Context, *GetConfigmapRequest) (*ConfigmapResponse, error)

func (UnimplementedConfigmapServiceServer) ListConfigmaps 

func (UnimplementedConfigmapServiceServer) ListConfigmaps(context.Context, *ListConfigmapsRequest) (*ListConfigmapsResponse, error)

func (UnimplementedConfigmapServiceServer) UpdateConfigmap 

func (UnimplementedConfigmapServiceServer) UpdateConfigmap(context.Context, *UpdateConfigmapRequest) (*ConfigmapResponse, error)

type UnimplementedExecServiceServer 

type UnimplementedExecServiceServer struct{}

UnimplementedExecServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedExecServiceServer) StreamExec 

func (UnimplementedExecServiceServer) StreamExec(grpc.BidiStreamingServer[ExecRequest, ExecResponse]) error

type UnimplementedHealthServiceServer 

type UnimplementedHealthServiceServer struct{}

UnimplementedHealthServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedHealthServiceServer) GetHealth 

func (UnimplementedHealthServiceServer) GetHealth(context.Context, *GetHealthRequest) (*GetHealthResponse, error)

func (UnimplementedHealthServiceServer) GetServerVersion 

func (UnimplementedHealthServiceServer) GetServerVersion(context.Context, *GetServerVersionRequest) (*GetServerVersionResponse, error)

type UnimplementedInstanceServiceServer 

type UnimplementedInstanceServiceServer struct{}

UnimplementedInstanceServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedInstanceServiceServer) GetInstance 

func (UnimplementedInstanceServiceServer) GetInstance(context.Context, *GetInstanceRequest) (*InstanceResponse, error)

func (UnimplementedInstanceServiceServer) ListInstances 

func (UnimplementedInstanceServiceServer) ListInstances(context.Context, *ListInstancesRequest) (*ListInstancesResponse, error)

func (UnimplementedInstanceServiceServer) RestartInstance 

func (UnimplementedInstanceServiceServer) RestartInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)

func (UnimplementedInstanceServiceServer) StartInstance 

func (UnimplementedInstanceServiceServer) StartInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)

func (UnimplementedInstanceServiceServer) StopInstance 

func (UnimplementedInstanceServiceServer) StopInstance(context.Context, *InstanceActionRequest) (*InstanceResponse, error)

func (UnimplementedInstanceServiceServer) WatchInstances 

func (UnimplementedInstanceServiceServer) WatchInstances(*WatchInstancesRequest, grpc.ServerStreamingServer[WatchInstancesResponse]) error

type UnimplementedLogServiceServer 

type UnimplementedLogServiceServer struct{}

UnimplementedLogServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedLogServiceServer) StreamLogs 

func (UnimplementedLogServiceServer) StreamLogs(grpc.BidiStreamingServer[LogRequest, LogResponse]) error

type UnimplementedNamespaceServiceServer 

type UnimplementedNamespaceServiceServer struct{}

UnimplementedNamespaceServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedNamespaceServiceServer) CreateNamespace 

func (UnimplementedNamespaceServiceServer) CreateNamespace(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error)

func (UnimplementedNamespaceServiceServer) DeleteNamespace 

func (UnimplementedNamespaceServiceServer) DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error)

func (UnimplementedNamespaceServiceServer) GetNamespace 

func (UnimplementedNamespaceServiceServer) GetNamespace(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error)

func (UnimplementedNamespaceServiceServer) ListNamespaces 

func (UnimplementedNamespaceServiceServer) ListNamespaces(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error)

func (UnimplementedNamespaceServiceServer) WatchNamespaces 

func (UnimplementedNamespaceServiceServer) WatchNamespaces(*WatchNamespacesRequest, grpc.ServerStreamingServer[WatchNamespacesResponse]) error

type UnimplementedSecretServiceServer 

type UnimplementedSecretServiceServer struct{}

UnimplementedSecretServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedSecretServiceServer) CreateSecret 

func (UnimplementedSecretServiceServer) CreateSecret(context.Context, *CreateSecretRequest) (*SecretResponse, error)

func (UnimplementedSecretServiceServer) DeleteSecret 

func (UnimplementedSecretServiceServer) DeleteSecret(context.Context, *DeleteSecretRequest) (*Status, error)

func (UnimplementedSecretServiceServer) GetSecret 

func (UnimplementedSecretServiceServer) GetSecret(context.Context, *GetSecretRequest) (*SecretResponse, error)

func (UnimplementedSecretServiceServer) ListSecretVersions 

func (UnimplementedSecretServiceServer) ListSecretVersions(context.Context, *ListSecretVersionsRequest) (*ListSecretVersionsResponse, error)

func (UnimplementedSecretServiceServer) ListSecrets 

func (UnimplementedSecretServiceServer) ListSecrets(context.Context, *ListSecretsRequest) (*ListSecretsResponse, error)

func (UnimplementedSecretServiceServer) RevealSecret 

func (UnimplementedSecretServiceServer) RevealSecret(context.Context, *RevealSecretRequest) (*SecretResponse, error)

func (UnimplementedSecretServiceServer) RevealSecretVersion 

func (UnimplementedSecretServiceServer) RevealSecretVersion(context.Context, *RevealSecretVersionRequest) (*SecretResponse, error)

func (UnimplementedSecretServiceServer) RollbackSecret 

func (UnimplementedSecretServiceServer) RollbackSecret(context.Context, *RollbackSecretRequest) (*SecretResponse, error)

func (UnimplementedSecretServiceServer) UpdateSecret 

func (UnimplementedSecretServiceServer) UpdateSecret(context.Context, *UpdateSecretRequest) (*SecretResponse, error)

type UnimplementedServiceServiceServer 

type UnimplementedServiceServiceServer struct{}

UnimplementedServiceServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedServiceServiceServer) CreateService 

func (UnimplementedServiceServiceServer) CreateService(context.Context, *CreateServiceRequest) (*ServiceResponse, error)

func (UnimplementedServiceServiceServer) DeleteService 

func (UnimplementedServiceServiceServer) DeleteService(context.Context, *DeleteServiceRequest) (*DeleteServiceResponse, error)

func (UnimplementedServiceServiceServer) GetDeletionStatus 

func (UnimplementedServiceServiceServer) GetDeletionStatus(context.Context, *GetDeletionStatusRequest) (*GetDeletionStatusResponse, error)

func (UnimplementedServiceServiceServer) GetService 

func (UnimplementedServiceServiceServer) GetService(context.Context, *GetServiceRequest) (*ServiceResponse, error)

func (UnimplementedServiceServiceServer) ListDeletionOperations 

func (UnimplementedServiceServiceServer) ListDeletionOperations(context.Context, *ListDeletionOperationsRequest) (*ListDeletionOperationsResponse, error)

func (UnimplementedServiceServiceServer) ListInstances 

func (UnimplementedServiceServiceServer) ListInstances(context.Context, *ListInstancesRequest) (*ListInstancesResponse, error)

func (UnimplementedServiceServiceServer) ListServices 

func (UnimplementedServiceServiceServer) ListServices(context.Context, *ListServicesRequest) (*ListServicesResponse, error)

func (UnimplementedServiceServiceServer) ScaleService 

func (UnimplementedServiceServiceServer) ScaleService(context.Context, *ScaleServiceRequest) (*ServiceResponse, error)

func (UnimplementedServiceServiceServer) UpdateService 

func (UnimplementedServiceServiceServer) UpdateService(context.Context, *UpdateServiceRequest) (*ServiceResponse, error)

func (UnimplementedServiceServiceServer) WatchScaling 

func (UnimplementedServiceServiceServer) WatchScaling(*WatchScalingRequest, grpc.ServerStreamingServer[ScalingStatusResponse]) error

func (UnimplementedServiceServiceServer) WatchServices 

func (UnimplementedServiceServiceServer) WatchServices(*WatchServicesRequest, grpc.ServerStreamingServer[WatchServicesResponse]) error

type UnimplementedSnapshotServiceServer 

type UnimplementedSnapshotServiceServer struct{}

UnimplementedSnapshotServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedSnapshotServiceServer) CreateSnapshot 

func (UnimplementedSnapshotServiceServer) CreateSnapshot(context.Context, *CreateSnapshotRequest) (*SnapshotResponse, error)

func (UnimplementedSnapshotServiceServer) DeleteSnapshot 

func (UnimplementedSnapshotServiceServer) DeleteSnapshot(context.Context, *DeleteSnapshotRequest) (*Status, error)

func (UnimplementedSnapshotServiceServer) GetSnapshot 

func (UnimplementedSnapshotServiceServer) GetSnapshot(context.Context, *GetSnapshotRequest) (*SnapshotResponse, error)

func (UnimplementedSnapshotServiceServer) ListSnapshots 

func (UnimplementedSnapshotServiceServer) ListSnapshots(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)

func (UnimplementedSnapshotServiceServer) RestoreVolume 

func (UnimplementedSnapshotServiceServer) RestoreVolume(context.Context, *RestoreVolumeRequest) (*VolumeResponse, error)

type UnimplementedStorageClassServiceServer 

type UnimplementedStorageClassServiceServer struct{}

UnimplementedStorageClassServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedStorageClassServiceServer) CreateStorageClass 

func (UnimplementedStorageClassServiceServer) CreateStorageClass(context.Context, *CreateStorageClassRequest) (*StorageClassResponse, error)

func (UnimplementedStorageClassServiceServer) DeleteStorageClass 

func (UnimplementedStorageClassServiceServer) DeleteStorageClass(context.Context, *DeleteStorageClassRequest) (*Status, error)

func (UnimplementedStorageClassServiceServer) GetStorageClass 

func (UnimplementedStorageClassServiceServer) GetStorageClass(context.Context, *GetStorageClassRequest) (*StorageClassResponse, error)

func (UnimplementedStorageClassServiceServer) ListStorageClasses 

func (UnimplementedStorageClassServiceServer) ListStorageClasses(context.Context, *ListStorageClassesRequest) (*ListStorageClassesResponse, error)

func (UnimplementedStorageClassServiceServer) UpdateStorageClass 

func (UnimplementedStorageClassServiceServer) UpdateStorageClass(context.Context, *UpdateStorageClassRequest) (*StorageClassResponse, error)

type UnimplementedVolumeServiceServer 

type UnimplementedVolumeServiceServer struct{}

UnimplementedVolumeServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedVolumeServiceServer) CreateVolume 

func (UnimplementedVolumeServiceServer) CreateVolume(context.Context, *CreateVolumeRequest) (*VolumeResponse, error)

func (UnimplementedVolumeServiceServer) DeleteVolume 

func (UnimplementedVolumeServiceServer) DeleteVolume(context.Context, *DeleteVolumeRequest) (*Status, error)

func (UnimplementedVolumeServiceServer) DetachVolume 

func (UnimplementedVolumeServiceServer) DetachVolume(context.Context, *DetachVolumeRequest) (*VolumeResponse, error)

func (UnimplementedVolumeServiceServer) GetVolume 

func (UnimplementedVolumeServiceServer) GetVolume(context.Context, *GetVolumeRequest) (*VolumeResponse, error)

func (UnimplementedVolumeServiceServer) ListVolumes 

func (UnimplementedVolumeServiceServer) ListVolumes(context.Context, *ListVolumesRequest) (*ListVolumesResponse, error)

func (UnimplementedVolumeServiceServer) RetryProvisionVolume 

func (UnimplementedVolumeServiceServer) RetryProvisionVolume(context.Context, *RetryProvisionVolumeRequest) (*VolumeResponse, error)

func (UnimplementedVolumeServiceServer) UpdateVolume 

func (UnimplementedVolumeServiceServer) UpdateVolume(context.Context, *UpdateVolumeRequest) (*VolumeResponse, error)

type UnimplementedWatchServiceServer 

type UnimplementedWatchServiceServer struct{}

UnimplementedWatchServiceServer must be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedWatchServiceServer) Subscribe 

func (UnimplementedWatchServiceServer) Subscribe(*SubscribeRequest, grpc.ServerStreamingServer[WatchEvent]) error

type UnsafeAdminServiceServer 

type UnsafeAdminServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAdminServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AdminServiceServer will result in compilation errors.

type UnsafeAuditServiceServer 

type UnsafeAuditServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAuditServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AuditServiceServer will result in compilation errors.

type UnsafeAuthServiceServer 

type UnsafeAuthServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAuthServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AuthServiceServer will result in compilation errors.

type UnsafeConfigmapServiceServer 

type UnsafeConfigmapServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeConfigmapServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ConfigmapServiceServer will result in compilation errors.

type UnsafeExecServiceServer 

type UnsafeExecServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeExecServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ExecServiceServer will result in compilation errors.

type UnsafeHealthServiceServer 

type UnsafeHealthServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeHealthServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to HealthServiceServer will result in compilation errors.

type UnsafeInstanceServiceServer 

type UnsafeInstanceServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeInstanceServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to InstanceServiceServer will result in compilation errors.

type UnsafeLogServiceServer 

type UnsafeLogServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeLogServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to LogServiceServer will result in compilation errors.

type UnsafeNamespaceServiceServer 

type UnsafeNamespaceServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNamespaceServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NamespaceServiceServer will result in compilation errors.

type UnsafeSecretServiceServer 

type UnsafeSecretServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeSecretServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to SecretServiceServer will result in compilation errors.

type UnsafeServiceServiceServer 

type UnsafeServiceServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeServiceServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ServiceServiceServer will result in compilation errors.

type UnsafeSnapshotServiceServer 

type UnsafeSnapshotServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeSnapshotServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to SnapshotServiceServer will result in compilation errors.

type UnsafeStorageClassServiceServer 

type UnsafeStorageClassServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeStorageClassServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to StorageClassServiceServer will result in compilation errors.

type UnsafeVolumeServiceServer 

type UnsafeVolumeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeVolumeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to VolumeServiceServer will result in compilation errors.

type UnsafeWatchServiceServer 

type UnsafeWatchServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeWatchServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to WatchServiceServer will result in compilation errors.

type UpdateConfigmapRequest 

type UpdateConfigmapRequest struct {
	Configmap *Configmap `protobuf:"bytes,1,opt,name=configmap,proto3" json:"configmap,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateConfigmapRequest) Descriptor deprecated 

func (*UpdateConfigmapRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateConfigmapRequest.ProtoReflect.Descriptor instead.

func (*UpdateConfigmapRequest) GetConfigmap 

func (x *UpdateConfigmapRequest) GetConfigmap() *Configmap

func (*UpdateConfigmapRequest) ProtoMessage 

func (*UpdateConfigmapRequest) ProtoMessage()

func (*UpdateConfigmapRequest) ProtoReflect 

func (x *UpdateConfigmapRequest) ProtoReflect() protoreflect.Message

func (*UpdateConfigmapRequest) Reset 

func (x *UpdateConfigmapRequest) Reset()

func (*UpdateConfigmapRequest) String 

func (x *UpdateConfigmapRequest) String() string

type UpdateRegistryRequest 

type UpdateRegistryRequest struct {
	Registry *RegistryConfig `protobuf:"bytes,1,opt,name=registry,proto3" json:"registry,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateRegistryRequest) Descriptor deprecated 

func (*UpdateRegistryRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateRegistryRequest.ProtoReflect.Descriptor instead.

func (*UpdateRegistryRequest) GetRegistry 

func (x *UpdateRegistryRequest) GetRegistry() *RegistryConfig

func (*UpdateRegistryRequest) ProtoMessage 

func (*UpdateRegistryRequest) ProtoMessage()

func (*UpdateRegistryRequest) ProtoReflect 

func (x *UpdateRegistryRequest) ProtoReflect() protoreflect.Message

func (*UpdateRegistryRequest) Reset 

func (x *UpdateRegistryRequest) Reset()

func (*UpdateRegistryRequest) String 

func (x *UpdateRegistryRequest) String() string

type UpdateRegistryResponse 

type UpdateRegistryResponse struct {
	Registry *RegistryConfig `protobuf:"bytes,1,opt,name=registry,proto3" json:"registry,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateRegistryResponse) Descriptor deprecated 

func (*UpdateRegistryResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpdateRegistryResponse.ProtoReflect.Descriptor instead.

func (*UpdateRegistryResponse) GetRegistry 

func (x *UpdateRegistryResponse) GetRegistry() *RegistryConfig

func (*UpdateRegistryResponse) ProtoMessage 

func (*UpdateRegistryResponse) ProtoMessage()

func (*UpdateRegistryResponse) ProtoReflect 

func (x *UpdateRegistryResponse) ProtoReflect() protoreflect.Message

func (*UpdateRegistryResponse) Reset 

func (x *UpdateRegistryResponse) Reset()

func (*UpdateRegistryResponse) String 

func (x *UpdateRegistryResponse) String() string

type UpdateSecretRequest 

type UpdateSecretRequest struct {
	Secret *Secret `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateSecretRequest) Descriptor deprecated 

func (*UpdateSecretRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateSecretRequest.ProtoReflect.Descriptor instead.

func (*UpdateSecretRequest) GetSecret 

func (x *UpdateSecretRequest) GetSecret() *Secret

func (*UpdateSecretRequest) ProtoMessage 

func (*UpdateSecretRequest) ProtoMessage()

func (*UpdateSecretRequest) ProtoReflect 

func (x *UpdateSecretRequest) ProtoReflect() protoreflect.Message

func (*UpdateSecretRequest) Reset 

func (x *UpdateSecretRequest) Reset()

func (*UpdateSecretRequest) String 

func (x *UpdateSecretRequest) String() string

type UpdateServiceRequest 

type UpdateServiceRequest struct {

	// Updated service definition
	Service *Service `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// Optional deployment tag
	DeploymentTag string `protobuf:"bytes,2,opt,name=deployment_tag,json=deploymentTag,proto3" json:"deployment_tag,omitempty"`
	// Force reconciliation even if no changes are detected
	Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
	// contains filtered or unexported fields
}

UpdateServiceRequest requests an update to a service.

func (*UpdateServiceRequest) Descriptor deprecated 

func (*UpdateServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateServiceRequest.ProtoReflect.Descriptor instead.

func (*UpdateServiceRequest) GetDeploymentTag 

func (x *UpdateServiceRequest) GetDeploymentTag() string

func (*UpdateServiceRequest) GetForce 

func (x *UpdateServiceRequest) GetForce() bool

func (*UpdateServiceRequest) GetService 

func (x *UpdateServiceRequest) GetService() *Service

func (*UpdateServiceRequest) ProtoMessage 

func (*UpdateServiceRequest) ProtoMessage()

func (*UpdateServiceRequest) ProtoReflect 

func (x *UpdateServiceRequest) ProtoReflect() protoreflect.Message

func (*UpdateServiceRequest) Reset 

func (x *UpdateServiceRequest) Reset()

func (*UpdateServiceRequest) String 

func (x *UpdateServiceRequest) String() string

type UpdateStorageClassRequest 

type UpdateStorageClassRequest struct {
	StorageClass *StorageClass `protobuf:"bytes,1,opt,name=storage_class,json=storageClass,proto3" json:"storage_class,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateStorageClassRequest) Descriptor deprecated 

func (*UpdateStorageClassRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateStorageClassRequest.ProtoReflect.Descriptor instead.

func (*UpdateStorageClassRequest) GetStorageClass 

func (x *UpdateStorageClassRequest) GetStorageClass() *StorageClass

func (*UpdateStorageClassRequest) ProtoMessage 

func (*UpdateStorageClassRequest) ProtoMessage()

func (*UpdateStorageClassRequest) ProtoReflect 

func (x *UpdateStorageClassRequest) ProtoReflect() protoreflect.Message

func (*UpdateStorageClassRequest) Reset 

func (x *UpdateStorageClassRequest) Reset()

func (*UpdateStorageClassRequest) String 

func (x *UpdateStorageClassRequest) String() string

type UpdateVolumeRequest 

type UpdateVolumeRequest struct {
	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateVolumeRequest) Descriptor deprecated 

func (*UpdateVolumeRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateVolumeRequest) GetVolume 

func (x *UpdateVolumeRequest) GetVolume() *Volume

func (*UpdateVolumeRequest) ProtoMessage 

func (*UpdateVolumeRequest) ProtoMessage()

func (*UpdateVolumeRequest) ProtoReflect 

func (x *UpdateVolumeRequest) ProtoReflect() protoreflect.Message

func (*UpdateVolumeRequest) Reset 

func (x *UpdateVolumeRequest) Reset()

func (*UpdateVolumeRequest) String 

func (x *UpdateVolumeRequest) String() string

type UserCreateRequest 

type UserCreateRequest struct {
	Name     string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Email    string   `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
	Policies []string `protobuf:"bytes,3,rep,name=policies,proto3" json:"policies,omitempty"` // names or ids
	// contains filtered or unexported fields
}

func (*UserCreateRequest) Descriptor deprecated 

func (*UserCreateRequest) Descriptor() ([]byte, []int)

Deprecated: Use UserCreateRequest.ProtoReflect.Descriptor instead.

func (*UserCreateRequest) GetEmail 

func (x *UserCreateRequest) GetEmail() string

func (*UserCreateRequest) GetName 

func (x *UserCreateRequest) GetName() string

func (*UserCreateRequest) GetPolicies 

func (x *UserCreateRequest) GetPolicies() []string

func (*UserCreateRequest) ProtoMessage 

func (*UserCreateRequest) ProtoMessage()

func (*UserCreateRequest) ProtoReflect 

func (x *UserCreateRequest) ProtoReflect() protoreflect.Message

func (*UserCreateRequest) Reset 

func (x *UserCreateRequest) Reset()

func (*UserCreateRequest) String 

func (x *UserCreateRequest) String() string

type UserCreateResponse 

type UserCreateResponse struct {
	User *Subject `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// contains filtered or unexported fields
}

func (*UserCreateResponse) Descriptor deprecated 

func (*UserCreateResponse) Descriptor() ([]byte, []int)

Deprecated: Use UserCreateResponse.ProtoReflect.Descriptor instead.

func (*UserCreateResponse) GetUser 

func (x *UserCreateResponse) GetUser() *Subject

func (*UserCreateResponse) ProtoMessage 

func (*UserCreateResponse) ProtoMessage()

func (*UserCreateResponse) ProtoReflect 

func (x *UserCreateResponse) ProtoReflect() protoreflect.Message

func (*UserCreateResponse) Reset 

func (x *UserCreateResponse) Reset()

func (*UserCreateResponse) String 

func (x *UserCreateResponse) String() string

type UserListRequest 

type UserListRequest struct {
	// contains filtered or unexported fields
}

func (*UserListRequest) Descriptor deprecated 

func (*UserListRequest) Descriptor() ([]byte, []int)

Deprecated: Use UserListRequest.ProtoReflect.Descriptor instead.

func (*UserListRequest) ProtoMessage 

func (*UserListRequest) ProtoMessage()

func (*UserListRequest) ProtoReflect 

func (x *UserListRequest) ProtoReflect() protoreflect.Message

func (*UserListRequest) Reset 

func (x *UserListRequest) Reset()

func (*UserListRequest) String 

func (x *UserListRequest) String() string

type UserListResponse 

type UserListResponse struct {
	Users []*Subject `protobuf:"bytes,1,rep,name=users,proto3" json:"users,omitempty"`
	// contains filtered or unexported fields
}

func (*UserListResponse) Descriptor deprecated 

func (*UserListResponse) Descriptor() ([]byte, []int)

Deprecated: Use UserListResponse.ProtoReflect.Descriptor instead.

func (*UserListResponse) GetUsers 

func (x *UserListResponse) GetUsers() []*Subject

func (*UserListResponse) ProtoMessage 

func (*UserListResponse) ProtoMessage()

func (*UserListResponse) ProtoReflect 

func (x *UserListResponse) ProtoReflect() protoreflect.Message

func (*UserListResponse) Reset 

func (x *UserListResponse) Reset()

func (*UserListResponse) String 

func (x *UserListResponse) String() string

type Volume 

type Volume struct {
	Id               string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name             string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Namespace        string            `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Labels           map[string]string `` /* 139-byte string literal not displayed */
	StorageClassName string            `protobuf:"bytes,5,opt,name=storage_class_name,json=storageClassName,proto3" json:"storage_class_name,omitempty"`
	Size             string            `protobuf:"bytes,6,opt,name=size,proto3" json:"size,omitempty"`
	// AccessMode is one of: "ReadWriteOnce", "ReadOnlyMany", "ReadWriteMany".
	AccessMode string `protobuf:"bytes,7,opt,name=access_mode,json=accessMode,proto3" json:"access_mode,omitempty"`
	// ReclaimPolicy override; one of: "retain", "delete". Empty defers to the
	// owning StorageClass.
	ReclaimPolicy    string            `protobuf:"bytes,8,opt,name=reclaim_policy,json=reclaimPolicy,proto3" json:"reclaim_policy,omitempty"`
	Parameters       map[string]string `` /* 147-byte string literal not displayed */
	SnapshotSchedule *SnapshotSchedule `protobuf:"bytes,10,opt,name=snapshot_schedule,json=snapshotSchedule,proto3" json:"snapshot_schedule,omitempty"`
	Handle           string            `protobuf:"bytes,11,opt,name=handle,proto3" json:"handle,omitempty"`
	OwnerService     string            `protobuf:"bytes,12,opt,name=owner_service,json=ownerService,proto3" json:"owner_service,omitempty"`
	BoundNode        string            `protobuf:"bytes,13,opt,name=bound_node,json=boundNode,proto3" json:"bound_node,omitempty"`
	BoundClaim       string            `protobuf:"bytes,14,opt,name=bound_claim,json=boundClaim,proto3" json:"bound_claim,omitempty"`
	// Status is one of: Pending, Provisioning, Available, Bound, Released,
	// Stalled, Failed.
	Status    string `protobuf:"bytes,15,opt,name=status,proto3" json:"status,omitempty"`
	Reason    string `protobuf:"bytes,16,opt,name=reason,proto3" json:"reason,omitempty"`
	Message   string `protobuf:"bytes,17,opt,name=message,proto3" json:"message,omitempty"`
	CreatedAt string `protobuf:"bytes,18,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt string `protobuf:"bytes,19,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

Volume mirrors pkg/types.Volume. Namespace-scoped.

func (*Volume) Descriptor deprecated 

func (*Volume) Descriptor() ([]byte, []int)

Deprecated: Use Volume.ProtoReflect.Descriptor instead.

func (*Volume) GetAccessMode 

func (x *Volume) GetAccessMode() string

func (*Volume) GetBoundClaim 

func (x *Volume) GetBoundClaim() string

func (*Volume) GetBoundNode 

func (x *Volume) GetBoundNode() string

func (*Volume) GetCreatedAt 

func (x *Volume) GetCreatedAt() string

func (*Volume) GetHandle 

func (x *Volume) GetHandle() string

func (*Volume) GetId 

func (x *Volume) GetId() string

func (*Volume) GetLabels 

func (x *Volume) GetLabels() map[string]string

func (*Volume) GetMessage 

func (x *Volume) GetMessage() string

func (*Volume) GetName 

func (x *Volume) GetName() string

func (*Volume) GetNamespace 

func (x *Volume) GetNamespace() string

func (*Volume) GetOwnerService 

func (x *Volume) GetOwnerService() string

func (*Volume) GetParameters 

func (x *Volume) GetParameters() map[string]string

func (*Volume) GetReason 

func (x *Volume) GetReason() string

func (*Volume) GetReclaimPolicy 

func (x *Volume) GetReclaimPolicy() string

func (*Volume) GetSize 

func (x *Volume) GetSize() string

func (*Volume) GetSnapshotSchedule 

func (x *Volume) GetSnapshotSchedule() *SnapshotSchedule

func (*Volume) GetStatus 

func (x *Volume) GetStatus() string

func (*Volume) GetStorageClassName 

func (x *Volume) GetStorageClassName() string

func (*Volume) GetUpdatedAt 

func (x *Volume) GetUpdatedAt() string

func (*Volume) ProtoMessage 

func (*Volume) ProtoMessage()

func (*Volume) ProtoReflect 

func (x *Volume) ProtoReflect() protoreflect.Message

func (*Volume) Reset 

func (x *Volume) Reset()

func (*Volume) String 

func (x *Volume) String() string

type VolumeClaim 

type VolumeClaim struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

VolumeClaim references an existing Volume by bare name (resolved in the service's namespace) or "<namespace>/<name>".

func (*VolumeClaim) Descriptor deprecated 

func (*VolumeClaim) Descriptor() ([]byte, []int)

Deprecated: Use VolumeClaim.ProtoReflect.Descriptor instead.

func (*VolumeClaim) GetName 

func (x *VolumeClaim) GetName() string

func (*VolumeClaim) ProtoMessage 

func (*VolumeClaim) ProtoMessage()

func (*VolumeClaim) ProtoReflect 

func (x *VolumeClaim) ProtoReflect() protoreflect.Message

func (*VolumeClaim) Reset 

func (x *VolumeClaim) Reset()

func (*VolumeClaim) String 

func (x *VolumeClaim) String() string

type VolumeClaimTemplate 

type VolumeClaimTemplate struct {
	StorageClassName string            `protobuf:"bytes,1,opt,name=storage_class_name,json=storageClassName,proto3" json:"storage_class_name,omitempty"`
	Size             string            `protobuf:"bytes,2,opt,name=size,proto3" json:"size,omitempty"`
	AccessMode       string            `protobuf:"bytes,3,opt,name=access_mode,json=accessMode,proto3" json:"access_mode,omitempty"`
	Parameters       map[string]string `` /* 147-byte string literal not displayed */
	ReclaimPolicy    string            `protobuf:"bytes,5,opt,name=reclaim_policy,json=reclaimPolicy,proto3" json:"reclaim_policy,omitempty"`
	// contains filtered or unexported fields
}

VolumeClaimTemplate provisions one Volume per replica.

func (*VolumeClaimTemplate) Descriptor deprecated 

func (*VolumeClaimTemplate) Descriptor() ([]byte, []int)

Deprecated: Use VolumeClaimTemplate.ProtoReflect.Descriptor instead.

func (*VolumeClaimTemplate) GetAccessMode 

func (x *VolumeClaimTemplate) GetAccessMode() string

func (*VolumeClaimTemplate) GetParameters 

func (x *VolumeClaimTemplate) GetParameters() map[string]string

func (*VolumeClaimTemplate) GetReclaimPolicy 

func (x *VolumeClaimTemplate) GetReclaimPolicy() string

func (*VolumeClaimTemplate) GetSize 

func (x *VolumeClaimTemplate) GetSize() string

func (*VolumeClaimTemplate) GetStorageClassName 

func (x *VolumeClaimTemplate) GetStorageClassName() string

func (*VolumeClaimTemplate) ProtoMessage 

func (*VolumeClaimTemplate) ProtoMessage()

func (*VolumeClaimTemplate) ProtoReflect 

func (x *VolumeClaimTemplate) ProtoReflect() protoreflect.Message

func (*VolumeClaimTemplate) Reset 

func (x *VolumeClaimTemplate) Reset()

func (*VolumeClaimTemplate) String 

func (x *VolumeClaimTemplate) String() string

type VolumeMount 

type VolumeMount struct {
	Name          string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	MountPath     string               `protobuf:"bytes,2,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	ReadOnly      bool                 `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
	SubPath       string               `protobuf:"bytes,4,opt,name=sub_path,json=subPath,proto3" json:"sub_path,omitempty"`
	Claim         *VolumeClaim         `protobuf:"bytes,5,opt,name=claim,proto3" json:"claim,omitempty"`
	ClaimTemplate *VolumeClaimTemplate `protobuf:"bytes,6,opt,name=claim_template,json=claimTemplate,proto3" json:"claim_template,omitempty"`
	// contains filtered or unexported fields
}

VolumeMount declares a volume reference inside a container. Exactly one of claim / claim_template is set.

func (*VolumeMount) Descriptor deprecated 

func (*VolumeMount) Descriptor() ([]byte, []int)

Deprecated: Use VolumeMount.ProtoReflect.Descriptor instead.

func (*VolumeMount) GetClaim 

func (x *VolumeMount) GetClaim() *VolumeClaim

func (*VolumeMount) GetClaimTemplate 

func (x *VolumeMount) GetClaimTemplate() *VolumeClaimTemplate

func (*VolumeMount) GetMountPath 

func (x *VolumeMount) GetMountPath() string

func (*VolumeMount) GetName 

func (x *VolumeMount) GetName() string

func (*VolumeMount) GetReadOnly 

func (x *VolumeMount) GetReadOnly() bool

func (*VolumeMount) GetSubPath 

func (x *VolumeMount) GetSubPath() string

func (*VolumeMount) ProtoMessage 

func (*VolumeMount) ProtoMessage()

func (*VolumeMount) ProtoReflect 

func (x *VolumeMount) ProtoReflect() protoreflect.Message

func (*VolumeMount) Reset 

func (x *VolumeMount) Reset()

func (*VolumeMount) String 

func (x *VolumeMount) String() string

type VolumeResponse 

type VolumeResponse struct {
	Volume *Volume `protobuf:"bytes,1,opt,name=volume,proto3" json:"volume,omitempty"`
	Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*VolumeResponse) Descriptor deprecated 

func (*VolumeResponse) Descriptor() ([]byte, []int)

Deprecated: Use VolumeResponse.ProtoReflect.Descriptor instead.

func (*VolumeResponse) GetStatus 

func (x *VolumeResponse) GetStatus() *Status

func (*VolumeResponse) GetVolume 

func (x *VolumeResponse) GetVolume() *Volume

func (*VolumeResponse) ProtoMessage 

func (*VolumeResponse) ProtoMessage()

func (*VolumeResponse) ProtoReflect 

func (x *VolumeResponse) ProtoReflect() protoreflect.Message

func (*VolumeResponse) Reset 

func (x *VolumeResponse) Reset()

func (*VolumeResponse) String 

func (x *VolumeResponse) String() string

type VolumeServiceClient 

type VolumeServiceClient interface {
	CreateVolume(ctx context.Context, in *CreateVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
	GetVolume(ctx context.Context, in *GetVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
	UpdateVolume(ctx context.Context, in *UpdateVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
	DeleteVolume(ctx context.Context, in *DeleteVolumeRequest, opts ...grpc.CallOption) (*Status, error)
	ListVolumes(ctx context.Context, in *ListVolumesRequest, opts ...grpc.CallOption) (*ListVolumesResponse, error)
	// RetryProvisionVolume re-arms a Failed/Stalled volume by transitioning
	// it back to Pending so the controller picks it up on the next watch
	// event. Returns the updated Volume.
	RetryProvisionVolume(ctx context.Context, in *RetryProvisionVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
	// DetachVolume clears bind state (BoundClaim/BoundNode) on a volume so
	// a replacement instance can attach it. With force=true the call is
	// allowed regardless of current status.
	DetachVolume(ctx context.Context, in *DetachVolumeRequest, opts ...grpc.CallOption) (*VolumeResponse, error)
}

VolumeServiceClient is the client API for VolumeService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewVolumeServiceClient 

func NewVolumeServiceClient(cc grpc.ClientConnInterface) VolumeServiceClient

type VolumeServiceServer 

type VolumeServiceServer interface {
	CreateVolume(context.Context, *CreateVolumeRequest) (*VolumeResponse, error)
	GetVolume(context.Context, *GetVolumeRequest) (*VolumeResponse, error)
	UpdateVolume(context.Context, *UpdateVolumeRequest) (*VolumeResponse, error)
	DeleteVolume(context.Context, *DeleteVolumeRequest) (*Status, error)
	ListVolumes(context.Context, *ListVolumesRequest) (*ListVolumesResponse, error)
	// RetryProvisionVolume re-arms a Failed/Stalled volume by transitioning
	// it back to Pending so the controller picks it up on the next watch
	// event. Returns the updated Volume.
	RetryProvisionVolume(context.Context, *RetryProvisionVolumeRequest) (*VolumeResponse, error)
	// DetachVolume clears bind state (BoundClaim/BoundNode) on a volume so
	// a replacement instance can attach it. With force=true the call is
	// allowed regardless of current status.
	DetachVolume(context.Context, *DetachVolumeRequest) (*VolumeResponse, error)
	// contains filtered or unexported methods
}

VolumeServiceServer is the server API for VolumeService service. All implementations must embed UnimplementedVolumeServiceServer for forward compatibility.

type WatchEvent 

type WatchEvent struct {

	// Types that are valid to be assigned to Payload:
	//
	//	*WatchEvent_Event
	//	*WatchEvent_Status
	Payload isWatchEvent_Payload `protobuf_oneof:"payload"`
	// contains filtered or unexported fields
}

WatchEvent is a single delivery from the watch stream. Exactly one of `event` or `status` is set.

func (*WatchEvent) Descriptor deprecated 

func (*WatchEvent) Descriptor() ([]byte, []int)

Deprecated: Use WatchEvent.ProtoReflect.Descriptor instead.

func (*WatchEvent) GetEvent 

func (x *WatchEvent) GetEvent() *OrderedEvent

func (*WatchEvent) GetPayload 

func (x *WatchEvent) GetPayload() isWatchEvent_Payload

func (*WatchEvent) GetStatus 

func (x *WatchEvent) GetStatus() *WatchStatus

func (*WatchEvent) ProtoMessage 

func (*WatchEvent) ProtoMessage()

func (*WatchEvent) ProtoReflect 

func (x *WatchEvent) ProtoReflect() protoreflect.Message

func (*WatchEvent) Reset 

func (x *WatchEvent) Reset()

func (*WatchEvent) String 

func (x *WatchEvent) String() string

type WatchEvent_Event 

type WatchEvent_Event struct {
	Event *OrderedEvent `protobuf:"bytes,1,opt,name=event,proto3,oneof"`
}

type WatchEvent_Status 

type WatchEvent_Status struct {
	Status *WatchStatus `protobuf:"bytes,2,opt,name=status,proto3,oneof"`
}

type WatchInstancesRequest 

type WatchInstancesRequest struct {

	// Namespace to watch instances from (optional, default: "default", use "*" for all namespaces)
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Service ID to filter by
	ServiceId string `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	// Filter instances by label
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Filter instances by field
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

WatchInstancesRequest requests to watch instances for changes.

func (*WatchInstancesRequest) Descriptor deprecated 

func (*WatchInstancesRequest) Descriptor() ([]byte, []int)

Deprecated: Use WatchInstancesRequest.ProtoReflect.Descriptor instead.

func (*WatchInstancesRequest) GetFieldSelector 

func (x *WatchInstancesRequest) GetFieldSelector() map[string]string

func (*WatchInstancesRequest) GetLabelSelector 

func (x *WatchInstancesRequest) GetLabelSelector() map[string]string

func (*WatchInstancesRequest) GetNamespace 

func (x *WatchInstancesRequest) GetNamespace() string

func (*WatchInstancesRequest) GetServiceId 

func (x *WatchInstancesRequest) GetServiceId() string

func (*WatchInstancesRequest) ProtoMessage 

func (*WatchInstancesRequest) ProtoMessage()

func (*WatchInstancesRequest) ProtoReflect 

func (x *WatchInstancesRequest) ProtoReflect() protoreflect.Message

func (*WatchInstancesRequest) Reset 

func (x *WatchInstancesRequest) Reset()

func (*WatchInstancesRequest) String 

func (x *WatchInstancesRequest) String() string

type WatchInstancesResponse 

type WatchInstancesResponse struct {

	// The instance that changed
	Instance *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	// Type of event (added, modified, deleted)
	EventType EventType `protobuf:"varint,2,opt,name=event_type,json=eventType,proto3,enum=rune.api.EventType" json:"event_type,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

WatchInstancesResponse returns instance change events.

func (*WatchInstancesResponse) Descriptor deprecated 

func (*WatchInstancesResponse) Descriptor() ([]byte, []int)

Deprecated: Use WatchInstancesResponse.ProtoReflect.Descriptor instead.

func (*WatchInstancesResponse) GetEventType 

func (x *WatchInstancesResponse) GetEventType() EventType

func (*WatchInstancesResponse) GetInstance 

func (x *WatchInstancesResponse) GetInstance() *Instance

func (*WatchInstancesResponse) GetStatus 

func (x *WatchInstancesResponse) GetStatus() *Status

func (*WatchInstancesResponse) ProtoMessage 

func (*WatchInstancesResponse) ProtoMessage()

func (*WatchInstancesResponse) ProtoReflect 

func (x *WatchInstancesResponse) ProtoReflect() protoreflect.Message

func (*WatchInstancesResponse) Reset 

func (x *WatchInstancesResponse) Reset()

func (*WatchInstancesResponse) String 

func (x *WatchInstancesResponse) String() string

type WatchNamespacesRequest 

type WatchNamespacesRequest struct {

	// Optional label selector for filtering namespaces
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Optional field selector for filtering namespaces
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

WatchNamespacesRequest is the request for watching namespaces.

func (*WatchNamespacesRequest) Descriptor deprecated 

func (*WatchNamespacesRequest) Descriptor() ([]byte, []int)

Deprecated: Use WatchNamespacesRequest.ProtoReflect.Descriptor instead.

func (*WatchNamespacesRequest) GetFieldSelector 

func (x *WatchNamespacesRequest) GetFieldSelector() map[string]string

func (*WatchNamespacesRequest) GetLabelSelector 

func (x *WatchNamespacesRequest) GetLabelSelector() map[string]string

func (*WatchNamespacesRequest) ProtoMessage 

func (*WatchNamespacesRequest) ProtoMessage()

func (*WatchNamespacesRequest) ProtoReflect 

func (x *WatchNamespacesRequest) ProtoReflect() protoreflect.Message

func (*WatchNamespacesRequest) Reset 

func (x *WatchNamespacesRequest) Reset()

func (*WatchNamespacesRequest) String 

func (x *WatchNamespacesRequest) String() string

type WatchNamespacesResponse 

type WatchNamespacesResponse struct {

	// The namespace that changed
	Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// The type of event
	EventType EventType `protobuf:"varint,2,opt,name=event_type,json=eventType,proto3,enum=rune.api.EventType" json:"event_type,omitempty"`
	// Status information
	Status *Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

WatchNamespacesResponse is the response for watching namespaces.

func (*WatchNamespacesResponse) Descriptor deprecated 

func (*WatchNamespacesResponse) Descriptor() ([]byte, []int)

Deprecated: Use WatchNamespacesResponse.ProtoReflect.Descriptor instead.

func (*WatchNamespacesResponse) GetEventType 

func (x *WatchNamespacesResponse) GetEventType() EventType

func (*WatchNamespacesResponse) GetNamespace 

func (x *WatchNamespacesResponse) GetNamespace() *Namespace

func (*WatchNamespacesResponse) GetStatus 

func (x *WatchNamespacesResponse) GetStatus() *Status

func (*WatchNamespacesResponse) ProtoMessage 

func (*WatchNamespacesResponse) ProtoMessage()

func (*WatchNamespacesResponse) ProtoReflect 

func (x *WatchNamespacesResponse) ProtoReflect() protoreflect.Message

func (*WatchNamespacesResponse) Reset 

func (x *WatchNamespacesResponse) Reset()

func (*WatchNamespacesResponse) String 

func (x *WatchNamespacesResponse) String() string

type WatchScalingRequest 

type WatchScalingRequest struct {

	// Name of the service to watch
	ServiceName string `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// Namespace of the service (optional, default: "default")
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Target scale to watch for (optional, if not specified, just watch current scaling operation)
	TargetScale int32 `protobuf:"varint,3,opt,name=target_scale,json=targetScale,proto3" json:"target_scale,omitempty"`
	// contains filtered or unexported fields
}

WatchScalingRequest requests to watch the scaling progress of a service.

func (*WatchScalingRequest) Descriptor deprecated 

func (*WatchScalingRequest) Descriptor() ([]byte, []int)

Deprecated: Use WatchScalingRequest.ProtoReflect.Descriptor instead.

func (*WatchScalingRequest) GetNamespace 

func (x *WatchScalingRequest) GetNamespace() string

func (*WatchScalingRequest) GetServiceName 

func (x *WatchScalingRequest) GetServiceName() string

func (*WatchScalingRequest) GetTargetScale 

func (x *WatchScalingRequest) GetTargetScale() int32

func (*WatchScalingRequest) ProtoMessage 

func (*WatchScalingRequest) ProtoMessage()

func (*WatchScalingRequest) ProtoReflect 

func (x *WatchScalingRequest) ProtoReflect() protoreflect.Message

func (*WatchScalingRequest) Reset 

func (x *WatchScalingRequest) Reset()

func (*WatchScalingRequest) String 

func (x *WatchScalingRequest) String() string

type WatchServiceClient 

type WatchServiceClient interface {
	// Subscribe streams events from from_seq forward.
	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[WatchEvent], error)
}

WatchServiceClient is the client API for WatchService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

WatchService streams ordered events from the control plane's OrderedLog to subscribers (typically the per-node agent).

The protocol is sequence-number based:

  • Every persisted event has a monotonic uint64 seq.
  • The client subscribes from `from_seq` (0 = from the beginning, known seq = strictly after that seq).
  • The server first replays buffered events from from_seq+1 through the current head, then streams live events as they are proposed. There is no gap between replay and live.
  • If the requested seq has been compacted out of the retention window, the server emits a single COMPACTED status response and closes the stream. The client must take a fresh Snapshot and resubscribe from snapshot.Seq.

Backpressure: the server enforces a per-stream send buffer. If the client falls behind, the server cancels the stream with SLOW_CONSUMER and the client must reconnect.

func NewWatchServiceClient 

func NewWatchServiceClient(cc grpc.ClientConnInterface) WatchServiceClient

type WatchServiceServer 

type WatchServiceServer interface {
	// Subscribe streams events from from_seq forward.
	Subscribe(*SubscribeRequest, grpc.ServerStreamingServer[WatchEvent]) error
	// contains filtered or unexported methods
}

WatchServiceServer is the server API for WatchService service. All implementations must embed UnimplementedWatchServiceServer for forward compatibility.

WatchService streams ordered events from the control plane's OrderedLog to subscribers (typically the per-node agent).

The protocol is sequence-number based:

  • Every persisted event has a monotonic uint64 seq.
  • The client subscribes from `from_seq` (0 = from the beginning, known seq = strictly after that seq).
  • The server first replays buffered events from from_seq+1 through the current head, then streams live events as they are proposed. There is no gap between replay and live.
  • If the requested seq has been compacted out of the retention window, the server emits a single COMPACTED status response and closes the stream. The client must take a fresh Snapshot and resubscribe from snapshot.Seq.

Backpressure: the server enforces a per-stream send buffer. If the client falls behind, the server cancels the stream with SLOW_CONSUMER and the client must reconnect.

type WatchService_SubscribeClient 

type WatchService_SubscribeClient = grpc.ServerStreamingClient[WatchEvent]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type WatchService_SubscribeServer 

type WatchService_SubscribeServer = grpc.ServerStreamingServer[WatchEvent]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type WatchServicesRequest 

type WatchServicesRequest struct {

	// Namespace to watch services from (optional, default: "default", use "*" for all namespaces)
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Filter services by label
	LabelSelector map[string]string `` /* 174-byte string literal not displayed */
	// Filter services by field
	FieldSelector map[string]string `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

WatchServicesRequest requests to watch services for changes.

func (*WatchServicesRequest) Descriptor deprecated 

func (*WatchServicesRequest) Descriptor() ([]byte, []int)

Deprecated: Use WatchServicesRequest.ProtoReflect.Descriptor instead.

func (*WatchServicesRequest) GetFieldSelector 

func (x *WatchServicesRequest) GetFieldSelector() map[string]string

func (*WatchServicesRequest) GetLabelSelector 

func (x *WatchServicesRequest) GetLabelSelector() map[string]string

func (*WatchServicesRequest) GetNamespace 

func (x *WatchServicesRequest) GetNamespace() string

func (*WatchServicesRequest) ProtoMessage 

func (*WatchServicesRequest) ProtoMessage()

func (*WatchServicesRequest) ProtoReflect 

func (x *WatchServicesRequest) ProtoReflect() protoreflect.Message

func (*WatchServicesRequest) Reset 

func (x *WatchServicesRequest) Reset()

func (*WatchServicesRequest) String 

func (x *WatchServicesRequest) String() string

type WatchServicesResponse 

type WatchServicesResponse struct {

	// The service that changed
	Service *Service `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// Type of event (added, modified, deleted)
	EventType EventType `protobuf:"varint,2,opt,name=event_type,json=eventType,proto3,enum=rune.api.EventType" json:"event_type,omitempty"`
	// Status message
	Status *Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

WatchServicesResponse returns service change events.

func (*WatchServicesResponse) Descriptor deprecated 

func (*WatchServicesResponse) Descriptor() ([]byte, []int)

Deprecated: Use WatchServicesResponse.ProtoReflect.Descriptor instead.

func (*WatchServicesResponse) GetEventType 

func (x *WatchServicesResponse) GetEventType() EventType

func (*WatchServicesResponse) GetService 

func (x *WatchServicesResponse) GetService() *Service

func (*WatchServicesResponse) GetStatus 

func (x *WatchServicesResponse) GetStatus() *Status

func (*WatchServicesResponse) ProtoMessage 

func (*WatchServicesResponse) ProtoMessage()

func (*WatchServicesResponse) ProtoReflect 

func (x *WatchServicesResponse) ProtoReflect() protoreflect.Message

func (*WatchServicesResponse) Reset 

func (x *WatchServicesResponse) Reset()

func (*WatchServicesResponse) String 

func (x *WatchServicesResponse) String() string

type WatchStatus 

type WatchStatus struct {
	Code    WatchStatus_Code `protobuf:"varint,1,opt,name=code,proto3,enum=rune.api.WatchStatus_Code" json:"code,omitempty"`
	Message string           `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// For CODE_COMPACTED: the lowest seq still in retention. The client
	// must take a Snapshot at or after this point.
	RetainedMinSeq uint64 `protobuf:"varint,3,opt,name=retained_min_seq,json=retainedMinSeq,proto3" json:"retained_min_seq,omitempty"`
	// contains filtered or unexported fields
}

WatchStatus is an out-of-band signal from the server.

func (*WatchStatus) Descriptor deprecated 

func (*WatchStatus) Descriptor() ([]byte, []int)

Deprecated: Use WatchStatus.ProtoReflect.Descriptor instead.

func (*WatchStatus) GetCode 

func (x *WatchStatus) GetCode() WatchStatus_Code

func (*WatchStatus) GetMessage 

func (x *WatchStatus) GetMessage() string

func (*WatchStatus) GetRetainedMinSeq 

func (x *WatchStatus) GetRetainedMinSeq() uint64

func (*WatchStatus) ProtoMessage 

func (*WatchStatus) ProtoMessage()

func (*WatchStatus) ProtoReflect 

func (x *WatchStatus) ProtoReflect() protoreflect.Message

func (*WatchStatus) Reset 

func (x *WatchStatus) Reset()

func (*WatchStatus) String 

func (x *WatchStatus) String() string

type WatchStatus_Code 

type WatchStatus_Code int32
const (
	WatchStatus_CODE_UNSPECIFIED WatchStatus_Code = 0
	// CODE_COMPACTED: from_seq is below the retained window. Client
	// must take a fresh Snapshot and resume from snapshot.Seq + 1.
	WatchStatus_CODE_COMPACTED WatchStatus_Code = 1
	// CODE_SLOW_CONSUMER: the client failed to drain the stream
	// within the server's send-buffer window. The stream is being
	// closed; the client should reconnect with the last seq it saw.
	WatchStatus_CODE_SLOW_CONSUMER WatchStatus_Code = 2
	// CODE_SHUTTING_DOWN: server is gracefully closing watches;
	// client should reconnect.
	WatchStatus_CODE_SHUTTING_DOWN WatchStatus_Code = 3
)

func (WatchStatus_Code) Descriptor 

func (WatchStatus_Code) Descriptor() protoreflect.EnumDescriptor

func (WatchStatus_Code) Enum 

func (x WatchStatus_Code) Enum() *WatchStatus_Code

func (WatchStatus_Code) EnumDescriptor deprecated 

func (WatchStatus_Code) EnumDescriptor() ([]byte, []int)

Deprecated: Use WatchStatus_Code.Descriptor instead.

func (WatchStatus_Code) Number 

func (x WatchStatus_Code) Number() protoreflect.EnumNumber

func (WatchStatus_Code) String 

func (x WatchStatus_Code) String() string

func (WatchStatus_Code) Type 

func (WatchStatus_Code) Type() protoreflect.EnumType

type WhoAmIRequest 

type WhoAmIRequest struct {
	// contains filtered or unexported fields
}

func (*WhoAmIRequest) Descriptor deprecated 

func (*WhoAmIRequest) Descriptor() ([]byte, []int)

Deprecated: Use WhoAmIRequest.ProtoReflect.Descriptor instead.

func (*WhoAmIRequest) ProtoMessage 

func (*WhoAmIRequest) ProtoMessage()

func (*WhoAmIRequest) ProtoReflect 

func (x *WhoAmIRequest) ProtoReflect() protoreflect.Message

func (*WhoAmIRequest) Reset 

func (x *WhoAmIRequest) Reset()

func (*WhoAmIRequest) String 

func (x *WhoAmIRequest) String() string

type WhoAmIResponse 

type WhoAmIResponse struct {
	SubjectId    string   `protobuf:"bytes,1,opt,name=subject_id,json=subjectId,proto3" json:"subject_id,omitempty"`
	SubjectName  string   `protobuf:"bytes,2,opt,name=subject_name,json=subjectName,proto3" json:"subject_name,omitempty"`    // User's display name
	SubjectEmail string   `protobuf:"bytes,3,opt,name=subject_email,json=subjectEmail,proto3" json:"subject_email,omitempty"` // User's email address
	Policies     []string `protobuf:"bytes,4,rep,name=policies,proto3" json:"policies,omitempty"`
	// contains filtered or unexported fields
}

func (*WhoAmIResponse) Descriptor deprecated 

func (*WhoAmIResponse) Descriptor() ([]byte, []int)

Deprecated: Use WhoAmIResponse.ProtoReflect.Descriptor instead.

func (*WhoAmIResponse) GetPolicies 

func (x *WhoAmIResponse) GetPolicies() []string

func (*WhoAmIResponse) GetSubjectEmail 

func (x *WhoAmIResponse) GetSubjectEmail() string

func (*WhoAmIResponse) GetSubjectId 

func (x *WhoAmIResponse) GetSubjectId() string

func (*WhoAmIResponse) GetSubjectName 

func (x *WhoAmIResponse) GetSubjectName() string

func (*WhoAmIResponse) ProtoMessage 

func (*WhoAmIResponse) ProtoMessage()

func (*WhoAmIResponse) ProtoReflect 

func (x *WhoAmIResponse) ProtoReflect() protoreflect.Message

func (*WhoAmIResponse) Reset 

func (x *WhoAmIResponse) Reset()

func (*WhoAmIResponse) String 

func (x *WhoAmIResponse) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.