_go

package
v0.0.0-...-6cd2180 Latest Latest
Warning

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

 Go to latest Published: Aug 8, 2024 License: Apache-2.0 Imports: 19 Imported by: 0

Documentation

Overview

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package _go is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

View Source 
const (
	AioVolumeService_CreateAioVolume_FullMethodName = "/opi_api.storage.v1.AioVolumeService/CreateAioVolume"
	AioVolumeService_DeleteAioVolume_FullMethodName = "/opi_api.storage.v1.AioVolumeService/DeleteAioVolume"
	AioVolumeService_UpdateAioVolume_FullMethodName = "/opi_api.storage.v1.AioVolumeService/UpdateAioVolume"
	AioVolumeService_ListAioVolumes_FullMethodName  = "/opi_api.storage.v1.AioVolumeService/ListAioVolumes"
	AioVolumeService_GetAioVolume_FullMethodName    = "/opi_api.storage.v1.AioVolumeService/GetAioVolume"
	AioVolumeService_StatsAioVolume_FullMethodName  = "/opi_api.storage.v1.AioVolumeService/StatsAioVolume"
)
View Source 
const (
	MallocVolumeService_CreateMallocVolume_FullMethodName = "/opi_api.storage.v1.MallocVolumeService/CreateMallocVolume"
	MallocVolumeService_DeleteMallocVolume_FullMethodName = "/opi_api.storage.v1.MallocVolumeService/DeleteMallocVolume"
	MallocVolumeService_UpdateMallocVolume_FullMethodName = "/opi_api.storage.v1.MallocVolumeService/UpdateMallocVolume"
	MallocVolumeService_ListMallocVolumes_FullMethodName  = "/opi_api.storage.v1.MallocVolumeService/ListMallocVolumes"
	MallocVolumeService_GetMallocVolume_FullMethodName    = "/opi_api.storage.v1.MallocVolumeService/GetMallocVolume"
	MallocVolumeService_StatsMallocVolume_FullMethodName  = "/opi_api.storage.v1.MallocVolumeService/StatsMallocVolume"
)
View Source 
const (
	NullVolumeService_CreateNullVolume_FullMethodName = "/opi_api.storage.v1.NullVolumeService/CreateNullVolume"
	NullVolumeService_DeleteNullVolume_FullMethodName = "/opi_api.storage.v1.NullVolumeService/DeleteNullVolume"
	NullVolumeService_UpdateNullVolume_FullMethodName = "/opi_api.storage.v1.NullVolumeService/UpdateNullVolume"
	NullVolumeService_ListNullVolumes_FullMethodName  = "/opi_api.storage.v1.NullVolumeService/ListNullVolumes"
	NullVolumeService_GetNullVolume_FullMethodName    = "/opi_api.storage.v1.NullVolumeService/GetNullVolume"
	NullVolumeService_StatsNullVolume_FullMethodName  = "/opi_api.storage.v1.NullVolumeService/StatsNullVolume"
)
View Source 
const (
	NvmeRemoteControllerService_CreateNvmeRemoteController_FullMethodName = "/opi_api.storage.v1.NvmeRemoteControllerService/CreateNvmeRemoteController"
	NvmeRemoteControllerService_DeleteNvmeRemoteController_FullMethodName = "/opi_api.storage.v1.NvmeRemoteControllerService/DeleteNvmeRemoteController"
	NvmeRemoteControllerService_UpdateNvmeRemoteController_FullMethodName = "/opi_api.storage.v1.NvmeRemoteControllerService/UpdateNvmeRemoteController"
	NvmeRemoteControllerService_ListNvmeRemoteControllers_FullMethodName  = "/opi_api.storage.v1.NvmeRemoteControllerService/ListNvmeRemoteControllers"
	NvmeRemoteControllerService_GetNvmeRemoteController_FullMethodName    = "/opi_api.storage.v1.NvmeRemoteControllerService/GetNvmeRemoteController"
	NvmeRemoteControllerService_ResetNvmeRemoteController_FullMethodName  = "/opi_api.storage.v1.NvmeRemoteControllerService/ResetNvmeRemoteController"
	NvmeRemoteControllerService_StatsNvmeRemoteController_FullMethodName  = "/opi_api.storage.v1.NvmeRemoteControllerService/StatsNvmeRemoteController"
	NvmeRemoteControllerService_ListNvmeRemoteNamespaces_FullMethodName   = "/opi_api.storage.v1.NvmeRemoteControllerService/ListNvmeRemoteNamespaces"
	NvmeRemoteControllerService_GetNvmeRemoteNamespace_FullMethodName     = "/opi_api.storage.v1.NvmeRemoteControllerService/GetNvmeRemoteNamespace"
	NvmeRemoteControllerService_CreateNvmePath_FullMethodName             = "/opi_api.storage.v1.NvmeRemoteControllerService/CreateNvmePath"
	NvmeRemoteControllerService_DeleteNvmePath_FullMethodName             = "/opi_api.storage.v1.NvmeRemoteControllerService/DeleteNvmePath"
	NvmeRemoteControllerService_UpdateNvmePath_FullMethodName             = "/opi_api.storage.v1.NvmeRemoteControllerService/UpdateNvmePath"
	NvmeRemoteControllerService_ListNvmePaths_FullMethodName              = "/opi_api.storage.v1.NvmeRemoteControllerService/ListNvmePaths"
	NvmeRemoteControllerService_GetNvmePath_FullMethodName                = "/opi_api.storage.v1.NvmeRemoteControllerService/GetNvmePath"
	NvmeRemoteControllerService_StatsNvmePath_FullMethodName              = "/opi_api.storage.v1.NvmeRemoteControllerService/StatsNvmePath"
)
View Source 
const (
	FrontendNvmeService_CreateNvmeSubsystem_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/CreateNvmeSubsystem"
	FrontendNvmeService_DeleteNvmeSubsystem_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/DeleteNvmeSubsystem"
	FrontendNvmeService_UpdateNvmeSubsystem_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/UpdateNvmeSubsystem"
	FrontendNvmeService_ListNvmeSubsystems_FullMethodName   = "/opi_api.storage.v1.FrontendNvmeService/ListNvmeSubsystems"
	FrontendNvmeService_GetNvmeSubsystem_FullMethodName     = "/opi_api.storage.v1.FrontendNvmeService/GetNvmeSubsystem"
	FrontendNvmeService_StatsNvmeSubsystem_FullMethodName   = "/opi_api.storage.v1.FrontendNvmeService/StatsNvmeSubsystem"
	FrontendNvmeService_CreateNvmeController_FullMethodName = "/opi_api.storage.v1.FrontendNvmeService/CreateNvmeController"
	FrontendNvmeService_DeleteNvmeController_FullMethodName = "/opi_api.storage.v1.FrontendNvmeService/DeleteNvmeController"
	FrontendNvmeService_UpdateNvmeController_FullMethodName = "/opi_api.storage.v1.FrontendNvmeService/UpdateNvmeController"
	FrontendNvmeService_ListNvmeControllers_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/ListNvmeControllers"
	FrontendNvmeService_GetNvmeController_FullMethodName    = "/opi_api.storage.v1.FrontendNvmeService/GetNvmeController"
	FrontendNvmeService_StatsNvmeController_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/StatsNvmeController"
	FrontendNvmeService_CreateNvmeNamespace_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/CreateNvmeNamespace"
	FrontendNvmeService_DeleteNvmeNamespace_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/DeleteNvmeNamespace"
	FrontendNvmeService_UpdateNvmeNamespace_FullMethodName  = "/opi_api.storage.v1.FrontendNvmeService/UpdateNvmeNamespace"
	FrontendNvmeService_ListNvmeNamespaces_FullMethodName   = "/opi_api.storage.v1.FrontendNvmeService/ListNvmeNamespaces"
	FrontendNvmeService_GetNvmeNamespace_FullMethodName     = "/opi_api.storage.v1.FrontendNvmeService/GetNvmeNamespace"
	FrontendNvmeService_StatsNvmeNamespace_FullMethodName   = "/opi_api.storage.v1.FrontendNvmeService/StatsNvmeNamespace"
)
View Source 
const (
	FrontendVirtioBlkService_CreateVirtioBlk_FullMethodName = "/opi_api.storage.v1.FrontendVirtioBlkService/CreateVirtioBlk"
	FrontendVirtioBlkService_DeleteVirtioBlk_FullMethodName = "/opi_api.storage.v1.FrontendVirtioBlkService/DeleteVirtioBlk"
	FrontendVirtioBlkService_UpdateVirtioBlk_FullMethodName = "/opi_api.storage.v1.FrontendVirtioBlkService/UpdateVirtioBlk"
	FrontendVirtioBlkService_ListVirtioBlks_FullMethodName  = "/opi_api.storage.v1.FrontendVirtioBlkService/ListVirtioBlks"
	FrontendVirtioBlkService_GetVirtioBlk_FullMethodName    = "/opi_api.storage.v1.FrontendVirtioBlkService/GetVirtioBlk"
	FrontendVirtioBlkService_StatsVirtioBlk_FullMethodName  = "/opi_api.storage.v1.FrontendVirtioBlkService/StatsVirtioBlk"
)
View Source 
const (
	FrontendVirtioScsiService_CreateVirtioScsiTarget_FullMethodName     = "/opi_api.storage.v1.FrontendVirtioScsiService/CreateVirtioScsiTarget"
	FrontendVirtioScsiService_DeleteVirtioScsiTarget_FullMethodName     = "/opi_api.storage.v1.FrontendVirtioScsiService/DeleteVirtioScsiTarget"
	FrontendVirtioScsiService_UpdateVirtioScsiTarget_FullMethodName     = "/opi_api.storage.v1.FrontendVirtioScsiService/UpdateVirtioScsiTarget"
	FrontendVirtioScsiService_ListVirtioScsiTargets_FullMethodName      = "/opi_api.storage.v1.FrontendVirtioScsiService/ListVirtioScsiTargets"
	FrontendVirtioScsiService_GetVirtioScsiTarget_FullMethodName        = "/opi_api.storage.v1.FrontendVirtioScsiService/GetVirtioScsiTarget"
	FrontendVirtioScsiService_StatsVirtioScsiTarget_FullMethodName      = "/opi_api.storage.v1.FrontendVirtioScsiService/StatsVirtioScsiTarget"
	FrontendVirtioScsiService_CreateVirtioScsiController_FullMethodName = "/opi_api.storage.v1.FrontendVirtioScsiService/CreateVirtioScsiController"
	FrontendVirtioScsiService_DeleteVirtioScsiController_FullMethodName = "/opi_api.storage.v1.FrontendVirtioScsiService/DeleteVirtioScsiController"
	FrontendVirtioScsiService_UpdateVirtioScsiController_FullMethodName = "/opi_api.storage.v1.FrontendVirtioScsiService/UpdateVirtioScsiController"
	FrontendVirtioScsiService_ListVirtioScsiControllers_FullMethodName  = "/opi_api.storage.v1.FrontendVirtioScsiService/ListVirtioScsiControllers"
	FrontendVirtioScsiService_GetVirtioScsiController_FullMethodName    = "/opi_api.storage.v1.FrontendVirtioScsiService/GetVirtioScsiController"
	FrontendVirtioScsiService_StatsVirtioScsiController_FullMethodName  = "/opi_api.storage.v1.FrontendVirtioScsiService/StatsVirtioScsiController"
	FrontendVirtioScsiService_CreateVirtioScsiLun_FullMethodName        = "/opi_api.storage.v1.FrontendVirtioScsiService/CreateVirtioScsiLun"
	FrontendVirtioScsiService_DeleteVirtioScsiLun_FullMethodName        = "/opi_api.storage.v1.FrontendVirtioScsiService/DeleteVirtioScsiLun"
	FrontendVirtioScsiService_UpdateVirtioScsiLun_FullMethodName        = "/opi_api.storage.v1.FrontendVirtioScsiService/UpdateVirtioScsiLun"
	FrontendVirtioScsiService_ListVirtioScsiLuns_FullMethodName         = "/opi_api.storage.v1.FrontendVirtioScsiService/ListVirtioScsiLuns"
	FrontendVirtioScsiService_GetVirtioScsiLun_FullMethodName           = "/opi_api.storage.v1.FrontendVirtioScsiService/GetVirtioScsiLun"
	FrontendVirtioScsiService_StatsVirtioScsiLun_FullMethodName         = "/opi_api.storage.v1.FrontendVirtioScsiService/StatsVirtioScsiLun"
)
View Source 
const (
	MiddleendEncryptionService_CreateEncryptedVolume_FullMethodName = "/opi_api.storage.v1.MiddleendEncryptionService/CreateEncryptedVolume"
	MiddleendEncryptionService_DeleteEncryptedVolume_FullMethodName = "/opi_api.storage.v1.MiddleendEncryptionService/DeleteEncryptedVolume"
	MiddleendEncryptionService_UpdateEncryptedVolume_FullMethodName = "/opi_api.storage.v1.MiddleendEncryptionService/UpdateEncryptedVolume"
	MiddleendEncryptionService_ListEncryptedVolumes_FullMethodName  = "/opi_api.storage.v1.MiddleendEncryptionService/ListEncryptedVolumes"
	MiddleendEncryptionService_GetEncryptedVolume_FullMethodName    = "/opi_api.storage.v1.MiddleendEncryptionService/GetEncryptedVolume"
	MiddleendEncryptionService_StatsEncryptedVolume_FullMethodName  = "/opi_api.storage.v1.MiddleendEncryptionService/StatsEncryptedVolume"
)
View Source 
const (
	MiddleendQosVolumeService_CreateQosVolume_FullMethodName = "/opi_api.storage.v1.MiddleendQosVolumeService/CreateQosVolume"
	MiddleendQosVolumeService_DeleteQosVolume_FullMethodName = "/opi_api.storage.v1.MiddleendQosVolumeService/DeleteQosVolume"
	MiddleendQosVolumeService_UpdateQosVolume_FullMethodName = "/opi_api.storage.v1.MiddleendQosVolumeService/UpdateQosVolume"
	MiddleendQosVolumeService_ListQosVolumes_FullMethodName  = "/opi_api.storage.v1.MiddleendQosVolumeService/ListQosVolumes"
	MiddleendQosVolumeService_GetQosVolume_FullMethodName    = "/opi_api.storage.v1.MiddleendQosVolumeService/GetQosVolume"
	MiddleendQosVolumeService_StatsQosVolume_FullMethodName  = "/opi_api.storage.v1.MiddleendQosVolumeService/StatsQosVolume"
)

Variables

View Source 
var (
	NvmeMultipath_name = map[int32]string{
		0: "NVME_MULTIPATH_UNSPECIFIED",
		1: "NVME_MULTIPATH_DISABLE",
		2: "NVME_MULTIPATH_FAILOVER",
		3: "NVME_MULTIPATH_MULTIPATH",
	}
	NvmeMultipath_value = map[string]int32{
		"NVME_MULTIPATH_UNSPECIFIED": 0,
		"NVME_MULTIPATH_DISABLE":     1,
		"NVME_MULTIPATH_FAILOVER":    2,
		"NVME_MULTIPATH_MULTIPATH":   3,
	}
)

Enum value maps for NvmeMultipath.

View Source 
var (
	NvmeNamespaceStatus_State_name = map[int32]string{
		0: "STATE_UNSPECIFIED",
		1: "STATE_DISABLED",
		2: "STATE_ENABLED",
		3: "STATE_DELETING",
	}
	NvmeNamespaceStatus_State_value = map[string]int32{
		"STATE_UNSPECIFIED": 0,
		"STATE_DISABLED":    1,
		"STATE_ENABLED":     2,
		"STATE_DELETING":    3,
	}
)

Enum value maps for NvmeNamespaceStatus_State.

View Source 
var (
	NvmeNamespaceStatus_OperState_name = map[int32]string{
		0: "OPER_STATE_UNSPECIFIED",
		1: "OPER_STATE_ONLINE",
		2: "OPER_STATE_OFFLINE",
	}
	NvmeNamespaceStatus_OperState_value = map[string]int32{
		"OPER_STATE_UNSPECIFIED": 0,
		"OPER_STATE_ONLINE":      1,
		"OPER_STATE_OFFLINE":     2,
	}
)

Enum value maps for NvmeNamespaceStatus_OperState.

View Source 
var (
	EncryptionType_name = map[int32]string{
		0: "ENCRYPTION_TYPE_UNSPECIFIED",
		1: "ENCRYPTION_TYPE_AES_CBC_128",
		2: "ENCRYPTION_TYPE_AES_CBC_192",
		3: "ENCRYPTION_TYPE_AES_CBC_256",
		4: "ENCRYPTION_TYPE_AES_XTS_128",
		5: "ENCRYPTION_TYPE_AES_XTS_192",
		6: "ENCRYPTION_TYPE_AES_XTS_256",
	}
	EncryptionType_value = map[string]int32{
		"ENCRYPTION_TYPE_UNSPECIFIED": 0,
		"ENCRYPTION_TYPE_AES_CBC_128": 1,
		"ENCRYPTION_TYPE_AES_CBC_192": 2,
		"ENCRYPTION_TYPE_AES_CBC_256": 3,
		"ENCRYPTION_TYPE_AES_XTS_128": 4,
		"ENCRYPTION_TYPE_AES_XTS_192": 5,
		"ENCRYPTION_TYPE_AES_XTS_256": 6,
	}
)

Enum value maps for EncryptionType.

View Source 
var (
	NvmeTransportType_name = map[int32]string{
		0: "NVME_TRANSPORT_TYPE_UNSPECIFIED",
		1: "NVME_TRANSPORT_TYPE_FC",
		2: "NVME_TRANSPORT_TYPE_PCIE",
		3: "NVME_TRANSPORT_TYPE_RDMA",
		4: "NVME_TRANSPORT_TYPE_TCP",
		5: "NVME_TRANSPORT_TYPE_CUSTOM",
	}
	NvmeTransportType_value = map[string]int32{
		"NVME_TRANSPORT_TYPE_UNSPECIFIED": 0,
		"NVME_TRANSPORT_TYPE_FC":          1,
		"NVME_TRANSPORT_TYPE_PCIE":        2,
		"NVME_TRANSPORT_TYPE_RDMA":        3,
		"NVME_TRANSPORT_TYPE_TCP":         4,
		"NVME_TRANSPORT_TYPE_CUSTOM":      5,
	}
)

Enum value maps for NvmeTransportType.

View Source 
var (
	NvmeAddressFamily_name = map[int32]string{
		0: "NVME_ADDRESS_FAMILY_UNSPECIFIED",
		1: "NVME_ADDRESS_FAMILY_IPV4",
		2: "NVME_ADDRESS_FAMILY_IPV6",
		3: "NVME_ADDRESS_FAMILY_IB",
		4: "NVME_ADDRESS_FAMILY_FC",
		5: "NVME_ADDRESS_FAMILY_INTRA_HOST",
	}
	NvmeAddressFamily_value = map[string]int32{
		"NVME_ADDRESS_FAMILY_UNSPECIFIED": 0,
		"NVME_ADDRESS_FAMILY_IPV4":        1,
		"NVME_ADDRESS_FAMILY_IPV6":        2,
		"NVME_ADDRESS_FAMILY_IB":          3,
		"NVME_ADDRESS_FAMILY_FC":          4,
		"NVME_ADDRESS_FAMILY_INTRA_HOST":  5,
	}
)

Enum value maps for NvmeAddressFamily.

View Source 
var AioVolumeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.AioVolumeService",
	HandlerType: (*AioVolumeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateAioVolume",
			Handler:    _AioVolumeService_CreateAioVolume_Handler,
		},
		{
			MethodName: "DeleteAioVolume",
			Handler:    _AioVolumeService_DeleteAioVolume_Handler,
		},
		{
			MethodName: "UpdateAioVolume",
			Handler:    _AioVolumeService_UpdateAioVolume_Handler,
		},
		{
			MethodName: "ListAioVolumes",
			Handler:    _AioVolumeService_ListAioVolumes_Handler,
		},
		{
			MethodName: "GetAioVolume",
			Handler:    _AioVolumeService_GetAioVolume_Handler,
		},
		{
			MethodName: "StatsAioVolume",
			Handler:    _AioVolumeService_StatsAioVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_aio.proto",
}

AioVolumeService_ServiceDesc is the grpc.ServiceDesc for AioVolumeService 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_backend_aio_proto protoreflect.FileDescriptor
View Source 
var File_backend_iscsi_proto protoreflect.FileDescriptor
View Source 
var File_backend_malloc_proto protoreflect.FileDescriptor
View Source 
var File_backend_null_proto protoreflect.FileDescriptor
View Source 
var File_backend_nvme_proto protoreflect.FileDescriptor
View Source 
var File_frontend_nvme_proto protoreflect.FileDescriptor
View Source 
var File_frontend_virtio_blk_proto protoreflect.FileDescriptor
View Source 
var File_frontend_virtio_fs_proto protoreflect.FileDescriptor
View Source 
var File_frontend_virtio_scsi_proto protoreflect.FileDescriptor
View Source 
var File_middleend_encryption_proto protoreflect.FileDescriptor
View Source 
var File_middleend_qos_volume_proto protoreflect.FileDescriptor
View Source 
var File_opicommon_proto protoreflect.FileDescriptor
View Source 
var FrontendNvmeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.FrontendNvmeService",
	HandlerType: (*FrontendNvmeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateNvmeSubsystem",
			Handler:    _FrontendNvmeService_CreateNvmeSubsystem_Handler,
		},
		{
			MethodName: "DeleteNvmeSubsystem",
			Handler:    _FrontendNvmeService_DeleteNvmeSubsystem_Handler,
		},
		{
			MethodName: "UpdateNvmeSubsystem",
			Handler:    _FrontendNvmeService_UpdateNvmeSubsystem_Handler,
		},
		{
			MethodName: "ListNvmeSubsystems",
			Handler:    _FrontendNvmeService_ListNvmeSubsystems_Handler,
		},
		{
			MethodName: "GetNvmeSubsystem",
			Handler:    _FrontendNvmeService_GetNvmeSubsystem_Handler,
		},
		{
			MethodName: "StatsNvmeSubsystem",
			Handler:    _FrontendNvmeService_StatsNvmeSubsystem_Handler,
		},
		{
			MethodName: "CreateNvmeController",
			Handler:    _FrontendNvmeService_CreateNvmeController_Handler,
		},
		{
			MethodName: "DeleteNvmeController",
			Handler:    _FrontendNvmeService_DeleteNvmeController_Handler,
		},
		{
			MethodName: "UpdateNvmeController",
			Handler:    _FrontendNvmeService_UpdateNvmeController_Handler,
		},
		{
			MethodName: "ListNvmeControllers",
			Handler:    _FrontendNvmeService_ListNvmeControllers_Handler,
		},
		{
			MethodName: "GetNvmeController",
			Handler:    _FrontendNvmeService_GetNvmeController_Handler,
		},
		{
			MethodName: "StatsNvmeController",
			Handler:    _FrontendNvmeService_StatsNvmeController_Handler,
		},
		{
			MethodName: "CreateNvmeNamespace",
			Handler:    _FrontendNvmeService_CreateNvmeNamespace_Handler,
		},
		{
			MethodName: "DeleteNvmeNamespace",
			Handler:    _FrontendNvmeService_DeleteNvmeNamespace_Handler,
		},
		{
			MethodName: "UpdateNvmeNamespace",
			Handler:    _FrontendNvmeService_UpdateNvmeNamespace_Handler,
		},
		{
			MethodName: "ListNvmeNamespaces",
			Handler:    _FrontendNvmeService_ListNvmeNamespaces_Handler,
		},
		{
			MethodName: "GetNvmeNamespace",
			Handler:    _FrontendNvmeService_GetNvmeNamespace_Handler,
		},
		{
			MethodName: "StatsNvmeNamespace",
			Handler:    _FrontendNvmeService_StatsNvmeNamespace_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "frontend_nvme.proto",
}

FrontendNvmeService_ServiceDesc is the grpc.ServiceDesc for FrontendNvmeService 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 FrontendVirtioBlkService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.FrontendVirtioBlkService",
	HandlerType: (*FrontendVirtioBlkServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateVirtioBlk",
			Handler:    _FrontendVirtioBlkService_CreateVirtioBlk_Handler,
		},
		{
			MethodName: "DeleteVirtioBlk",
			Handler:    _FrontendVirtioBlkService_DeleteVirtioBlk_Handler,
		},
		{
			MethodName: "UpdateVirtioBlk",
			Handler:    _FrontendVirtioBlkService_UpdateVirtioBlk_Handler,
		},
		{
			MethodName: "ListVirtioBlks",
			Handler:    _FrontendVirtioBlkService_ListVirtioBlks_Handler,
		},
		{
			MethodName: "GetVirtioBlk",
			Handler:    _FrontendVirtioBlkService_GetVirtioBlk_Handler,
		},
		{
			MethodName: "StatsVirtioBlk",
			Handler:    _FrontendVirtioBlkService_StatsVirtioBlk_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "frontend_virtio_blk.proto",
}

FrontendVirtioBlkService_ServiceDesc is the grpc.ServiceDesc for FrontendVirtioBlkService 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 FrontendVirtioScsiService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.FrontendVirtioScsiService",
	HandlerType: (*FrontendVirtioScsiServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateVirtioScsiTarget",
			Handler:    _FrontendVirtioScsiService_CreateVirtioScsiTarget_Handler,
		},
		{
			MethodName: "DeleteVirtioScsiTarget",
			Handler:    _FrontendVirtioScsiService_DeleteVirtioScsiTarget_Handler,
		},
		{
			MethodName: "UpdateVirtioScsiTarget",
			Handler:    _FrontendVirtioScsiService_UpdateVirtioScsiTarget_Handler,
		},
		{
			MethodName: "ListVirtioScsiTargets",
			Handler:    _FrontendVirtioScsiService_ListVirtioScsiTargets_Handler,
		},
		{
			MethodName: "GetVirtioScsiTarget",
			Handler:    _FrontendVirtioScsiService_GetVirtioScsiTarget_Handler,
		},
		{
			MethodName: "StatsVirtioScsiTarget",
			Handler:    _FrontendVirtioScsiService_StatsVirtioScsiTarget_Handler,
		},
		{
			MethodName: "CreateVirtioScsiController",
			Handler:    _FrontendVirtioScsiService_CreateVirtioScsiController_Handler,
		},
		{
			MethodName: "DeleteVirtioScsiController",
			Handler:    _FrontendVirtioScsiService_DeleteVirtioScsiController_Handler,
		},
		{
			MethodName: "UpdateVirtioScsiController",
			Handler:    _FrontendVirtioScsiService_UpdateVirtioScsiController_Handler,
		},
		{
			MethodName: "ListVirtioScsiControllers",
			Handler:    _FrontendVirtioScsiService_ListVirtioScsiControllers_Handler,
		},
		{
			MethodName: "GetVirtioScsiController",
			Handler:    _FrontendVirtioScsiService_GetVirtioScsiController_Handler,
		},
		{
			MethodName: "StatsVirtioScsiController",
			Handler:    _FrontendVirtioScsiService_StatsVirtioScsiController_Handler,
		},
		{
			MethodName: "CreateVirtioScsiLun",
			Handler:    _FrontendVirtioScsiService_CreateVirtioScsiLun_Handler,
		},
		{
			MethodName: "DeleteVirtioScsiLun",
			Handler:    _FrontendVirtioScsiService_DeleteVirtioScsiLun_Handler,
		},
		{
			MethodName: "UpdateVirtioScsiLun",
			Handler:    _FrontendVirtioScsiService_UpdateVirtioScsiLun_Handler,
		},
		{
			MethodName: "ListVirtioScsiLuns",
			Handler:    _FrontendVirtioScsiService_ListVirtioScsiLuns_Handler,
		},
		{
			MethodName: "GetVirtioScsiLun",
			Handler:    _FrontendVirtioScsiService_GetVirtioScsiLun_Handler,
		},
		{
			MethodName: "StatsVirtioScsiLun",
			Handler:    _FrontendVirtioScsiService_StatsVirtioScsiLun_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "frontend_virtio_scsi.proto",
}

FrontendVirtioScsiService_ServiceDesc is the grpc.ServiceDesc for FrontendVirtioScsiService 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 MallocVolumeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.MallocVolumeService",
	HandlerType: (*MallocVolumeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateMallocVolume",
			Handler:    _MallocVolumeService_CreateMallocVolume_Handler,
		},
		{
			MethodName: "DeleteMallocVolume",
			Handler:    _MallocVolumeService_DeleteMallocVolume_Handler,
		},
		{
			MethodName: "UpdateMallocVolume",
			Handler:    _MallocVolumeService_UpdateMallocVolume_Handler,
		},
		{
			MethodName: "ListMallocVolumes",
			Handler:    _MallocVolumeService_ListMallocVolumes_Handler,
		},
		{
			MethodName: "GetMallocVolume",
			Handler:    _MallocVolumeService_GetMallocVolume_Handler,
		},
		{
			MethodName: "StatsMallocVolume",
			Handler:    _MallocVolumeService_StatsMallocVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_malloc.proto",
}

MallocVolumeService_ServiceDesc is the grpc.ServiceDesc for MallocVolumeService 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 MiddleendEncryptionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.MiddleendEncryptionService",
	HandlerType: (*MiddleendEncryptionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateEncryptedVolume",
			Handler:    _MiddleendEncryptionService_CreateEncryptedVolume_Handler,
		},
		{
			MethodName: "DeleteEncryptedVolume",
			Handler:    _MiddleendEncryptionService_DeleteEncryptedVolume_Handler,
		},
		{
			MethodName: "UpdateEncryptedVolume",
			Handler:    _MiddleendEncryptionService_UpdateEncryptedVolume_Handler,
		},
		{
			MethodName: "ListEncryptedVolumes",
			Handler:    _MiddleendEncryptionService_ListEncryptedVolumes_Handler,
		},
		{
			MethodName: "GetEncryptedVolume",
			Handler:    _MiddleendEncryptionService_GetEncryptedVolume_Handler,
		},
		{
			MethodName: "StatsEncryptedVolume",
			Handler:    _MiddleendEncryptionService_StatsEncryptedVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "middleend_encryption.proto",
}

MiddleendEncryptionService_ServiceDesc is the grpc.ServiceDesc for MiddleendEncryptionService 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 MiddleendQosVolumeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.MiddleendQosVolumeService",
	HandlerType: (*MiddleendQosVolumeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateQosVolume",
			Handler:    _MiddleendQosVolumeService_CreateQosVolume_Handler,
		},
		{
			MethodName: "DeleteQosVolume",
			Handler:    _MiddleendQosVolumeService_DeleteQosVolume_Handler,
		},
		{
			MethodName: "UpdateQosVolume",
			Handler:    _MiddleendQosVolumeService_UpdateQosVolume_Handler,
		},
		{
			MethodName: "ListQosVolumes",
			Handler:    _MiddleendQosVolumeService_ListQosVolumes_Handler,
		},
		{
			MethodName: "GetQosVolume",
			Handler:    _MiddleendQosVolumeService_GetQosVolume_Handler,
		},
		{
			MethodName: "StatsQosVolume",
			Handler:    _MiddleendQosVolumeService_StatsQosVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "middleend_qos_volume.proto",
}

MiddleendQosVolumeService_ServiceDesc is the grpc.ServiceDesc for MiddleendQosVolumeService 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 NullVolumeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.NullVolumeService",
	HandlerType: (*NullVolumeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateNullVolume",
			Handler:    _NullVolumeService_CreateNullVolume_Handler,
		},
		{
			MethodName: "DeleteNullVolume",
			Handler:    _NullVolumeService_DeleteNullVolume_Handler,
		},
		{
			MethodName: "UpdateNullVolume",
			Handler:    _NullVolumeService_UpdateNullVolume_Handler,
		},
		{
			MethodName: "ListNullVolumes",
			Handler:    _NullVolumeService_ListNullVolumes_Handler,
		},
		{
			MethodName: "GetNullVolume",
			Handler:    _NullVolumeService_GetNullVolume_Handler,
		},
		{
			MethodName: "StatsNullVolume",
			Handler:    _NullVolumeService_StatsNullVolume_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_null.proto",
}

NullVolumeService_ServiceDesc is the grpc.ServiceDesc for NullVolumeService 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 NvmeRemoteControllerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "opi_api.storage.v1.NvmeRemoteControllerService",
	HandlerType: (*NvmeRemoteControllerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_CreateNvmeRemoteController_Handler,
		},
		{
			MethodName: "DeleteNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_DeleteNvmeRemoteController_Handler,
		},
		{
			MethodName: "UpdateNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_UpdateNvmeRemoteController_Handler,
		},
		{
			MethodName: "ListNvmeRemoteControllers",
			Handler:    _NvmeRemoteControllerService_ListNvmeRemoteControllers_Handler,
		},
		{
			MethodName: "GetNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_GetNvmeRemoteController_Handler,
		},
		{
			MethodName: "ResetNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_ResetNvmeRemoteController_Handler,
		},
		{
			MethodName: "StatsNvmeRemoteController",
			Handler:    _NvmeRemoteControllerService_StatsNvmeRemoteController_Handler,
		},
		{
			MethodName: "ListNvmeRemoteNamespaces",
			Handler:    _NvmeRemoteControllerService_ListNvmeRemoteNamespaces_Handler,
		},
		{
			MethodName: "GetNvmeRemoteNamespace",
			Handler:    _NvmeRemoteControllerService_GetNvmeRemoteNamespace_Handler,
		},
		{
			MethodName: "CreateNvmePath",
			Handler:    _NvmeRemoteControllerService_CreateNvmePath_Handler,
		},
		{
			MethodName: "DeleteNvmePath",
			Handler:    _NvmeRemoteControllerService_DeleteNvmePath_Handler,
		},
		{
			MethodName: "UpdateNvmePath",
			Handler:    _NvmeRemoteControllerService_UpdateNvmePath_Handler,
		},
		{
			MethodName: "ListNvmePaths",
			Handler:    _NvmeRemoteControllerService_ListNvmePaths_Handler,
		},
		{
			MethodName: "GetNvmePath",
			Handler:    _NvmeRemoteControllerService_GetNvmePath_Handler,
		},
		{
			MethodName: "StatsNvmePath",
			Handler:    _NvmeRemoteControllerService_StatsNvmePath_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_nvme.proto",
}

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

Functions

func RegisterAioVolumeServiceHandler 

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

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

func RegisterAioVolumeServiceHandlerClient 

func RegisterAioVolumeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AioVolumeServiceClient) error

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

func RegisterAioVolumeServiceHandlerFromEndpoint 

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

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

func RegisterAioVolumeServiceHandlerServer 

func RegisterAioVolumeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AioVolumeServiceServer) error

RegisterAioVolumeServiceHandlerServer registers the http handlers for service AioVolumeService to "mux". UnaryRPC :call AioVolumeServiceServer 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 RegisterAioVolumeServiceHandlerFromEndpoint instead.

func RegisterAioVolumeServiceServer 

func RegisterAioVolumeServiceServer(s grpc.ServiceRegistrar, srv AioVolumeServiceServer)

func RegisterFrontendNvmeServiceHandler 

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

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

func RegisterFrontendNvmeServiceHandlerClient 

func RegisterFrontendNvmeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FrontendNvmeServiceClient) error

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

func RegisterFrontendNvmeServiceHandlerFromEndpoint 

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

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

func RegisterFrontendNvmeServiceHandlerServer 

func RegisterFrontendNvmeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FrontendNvmeServiceServer) error

RegisterFrontendNvmeServiceHandlerServer registers the http handlers for service FrontendNvmeService to "mux". UnaryRPC :call FrontendNvmeServiceServer 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 RegisterFrontendNvmeServiceHandlerFromEndpoint instead.

func RegisterFrontendNvmeServiceServer 

func RegisterFrontendNvmeServiceServer(s grpc.ServiceRegistrar, srv FrontendNvmeServiceServer)

func RegisterFrontendVirtioBlkServiceHandler 

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

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

func RegisterFrontendVirtioBlkServiceHandlerClient 

func RegisterFrontendVirtioBlkServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FrontendVirtioBlkServiceClient) error

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

func RegisterFrontendVirtioBlkServiceHandlerFromEndpoint 

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

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

func RegisterFrontendVirtioBlkServiceHandlerServer 

func RegisterFrontendVirtioBlkServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FrontendVirtioBlkServiceServer) error

RegisterFrontendVirtioBlkServiceHandlerServer registers the http handlers for service FrontendVirtioBlkService to "mux". UnaryRPC :call FrontendVirtioBlkServiceServer 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 RegisterFrontendVirtioBlkServiceHandlerFromEndpoint instead.

func RegisterFrontendVirtioBlkServiceServer 

func RegisterFrontendVirtioBlkServiceServer(s grpc.ServiceRegistrar, srv FrontendVirtioBlkServiceServer)

func RegisterFrontendVirtioScsiServiceHandler 

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

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

func RegisterFrontendVirtioScsiServiceHandlerClient 

func RegisterFrontendVirtioScsiServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FrontendVirtioScsiServiceClient) error

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

func RegisterFrontendVirtioScsiServiceHandlerFromEndpoint 

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

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

func RegisterFrontendVirtioScsiServiceHandlerServer 

func RegisterFrontendVirtioScsiServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FrontendVirtioScsiServiceServer) error

RegisterFrontendVirtioScsiServiceHandlerServer registers the http handlers for service FrontendVirtioScsiService to "mux". UnaryRPC :call FrontendVirtioScsiServiceServer 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 RegisterFrontendVirtioScsiServiceHandlerFromEndpoint instead.

func RegisterFrontendVirtioScsiServiceServer 

func RegisterFrontendVirtioScsiServiceServer(s grpc.ServiceRegistrar, srv FrontendVirtioScsiServiceServer)

func RegisterMallocVolumeServiceHandler 

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

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

func RegisterMallocVolumeServiceHandlerClient 

func RegisterMallocVolumeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MallocVolumeServiceClient) error

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

func RegisterMallocVolumeServiceHandlerFromEndpoint 

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

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

func RegisterMallocVolumeServiceHandlerServer 

func RegisterMallocVolumeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MallocVolumeServiceServer) error

RegisterMallocVolumeServiceHandlerServer registers the http handlers for service MallocVolumeService to "mux". UnaryRPC :call MallocVolumeServiceServer 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 RegisterMallocVolumeServiceHandlerFromEndpoint instead.

func RegisterMallocVolumeServiceServer 

func RegisterMallocVolumeServiceServer(s grpc.ServiceRegistrar, srv MallocVolumeServiceServer)

func RegisterMiddleendEncryptionServiceHandler 

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

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

func RegisterMiddleendEncryptionServiceHandlerClient 

func RegisterMiddleendEncryptionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MiddleendEncryptionServiceClient) error

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

func RegisterMiddleendEncryptionServiceHandlerFromEndpoint 

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

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

func RegisterMiddleendEncryptionServiceHandlerServer 

func RegisterMiddleendEncryptionServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MiddleendEncryptionServiceServer) error

RegisterMiddleendEncryptionServiceHandlerServer registers the http handlers for service MiddleendEncryptionService to "mux". UnaryRPC :call MiddleendEncryptionServiceServer 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 RegisterMiddleendEncryptionServiceHandlerFromEndpoint instead.

func RegisterMiddleendEncryptionServiceServer 

func RegisterMiddleendEncryptionServiceServer(s grpc.ServiceRegistrar, srv MiddleendEncryptionServiceServer)

func RegisterMiddleendQosVolumeServiceHandler 

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

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

func RegisterMiddleendQosVolumeServiceHandlerClient 

func RegisterMiddleendQosVolumeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MiddleendQosVolumeServiceClient) error

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

func RegisterMiddleendQosVolumeServiceHandlerFromEndpoint 

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

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

func RegisterMiddleendQosVolumeServiceHandlerServer 

func RegisterMiddleendQosVolumeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MiddleendQosVolumeServiceServer) error

RegisterMiddleendQosVolumeServiceHandlerServer registers the http handlers for service MiddleendQosVolumeService to "mux". UnaryRPC :call MiddleendQosVolumeServiceServer 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 RegisterMiddleendQosVolumeServiceHandlerFromEndpoint instead.

func RegisterMiddleendQosVolumeServiceServer 

func RegisterMiddleendQosVolumeServiceServer(s grpc.ServiceRegistrar, srv MiddleendQosVolumeServiceServer)

func RegisterNullVolumeServiceHandler 

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

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

func RegisterNullVolumeServiceHandlerClient 

func RegisterNullVolumeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NullVolumeServiceClient) error

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

func RegisterNullVolumeServiceHandlerFromEndpoint 

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

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

func RegisterNullVolumeServiceHandlerServer 

func RegisterNullVolumeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NullVolumeServiceServer) error

RegisterNullVolumeServiceHandlerServer registers the http handlers for service NullVolumeService to "mux". UnaryRPC :call NullVolumeServiceServer 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 RegisterNullVolumeServiceHandlerFromEndpoint instead.

func RegisterNullVolumeServiceServer 

func RegisterNullVolumeServiceServer(s grpc.ServiceRegistrar, srv NullVolumeServiceServer)

func RegisterNvmeRemoteControllerServiceHandler 

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

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

func RegisterNvmeRemoteControllerServiceHandlerClient 

func RegisterNvmeRemoteControllerServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NvmeRemoteControllerServiceClient) error

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

func RegisterNvmeRemoteControllerServiceHandlerFromEndpoint 

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

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

func RegisterNvmeRemoteControllerServiceHandlerServer 

func RegisterNvmeRemoteControllerServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NvmeRemoteControllerServiceServer) error

RegisterNvmeRemoteControllerServiceHandlerServer registers the http handlers for service NvmeRemoteControllerService to "mux". UnaryRPC :call NvmeRemoteControllerServiceServer 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 RegisterNvmeRemoteControllerServiceHandlerFromEndpoint instead.

func RegisterNvmeRemoteControllerServiceServer 

func RegisterNvmeRemoteControllerServiceServer(s grpc.ServiceRegistrar, srv NvmeRemoteControllerServiceServer)

Types

type AioVolume 

type AioVolume struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The size of each block in the AioVolume.
	BlockSize int64 `protobuf:"varint,2,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
	// The total number of blocks in the AioVolume.
	BlocksCount int64 `protobuf:"varint,3,opt,name=blocks_count,json=blocksCount,proto3" json:"blocks_count,omitempty"`
	// The UUID (Universally Unique Identifier) of the AioVolume.
	Uuid string `protobuf:"bytes,4,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// The filename associated with the AioVolume.
	Filename string `protobuf:"bytes,5,opt,name=filename,proto3" json:"filename,omitempty"`
	// contains filtered or unexported fields
}

Volume represented by Linux kernel block device or a file on a Linux filesystem

func (*AioVolume) Descriptor deprecated 

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

Deprecated: Use AioVolume.ProtoReflect.Descriptor instead.

func (*AioVolume) GetBlockSize 

func (x *AioVolume) GetBlockSize() int64

func (*AioVolume) GetBlocksCount 

func (x *AioVolume) GetBlocksCount() int64

func (*AioVolume) GetFilename 

func (x *AioVolume) GetFilename() string

func (*AioVolume) GetName 

func (x *AioVolume) GetName() string

func (*AioVolume) GetUuid 

func (x *AioVolume) GetUuid() string

func (*AioVolume) ProtoMessage 

func (*AioVolume) ProtoMessage()

func (*AioVolume) ProtoReflect 

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

func (*AioVolume) Reset 

func (x *AioVolume) Reset()

func (*AioVolume) String 

func (x *AioVolume) String() string

type AioVolumeServiceClient 

type AioVolumeServiceClient interface {
	// Create an Aio Volume
	CreateAioVolume(ctx context.Context, in *CreateAioVolumeRequest, opts ...grpc.CallOption) (*AioVolume, error)
	// Delete an Aio Volume
	DeleteAioVolume(ctx context.Context, in *DeleteAioVolumeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Aio Volume
	UpdateAioVolume(ctx context.Context, in *UpdateAioVolumeRequest, opts ...grpc.CallOption) (*AioVolume, error)
	// List Aio Volumes
	ListAioVolumes(ctx context.Context, in *ListAioVolumesRequest, opts ...grpc.CallOption) (*ListAioVolumesResponse, error)
	// Get an Aio Volume
	GetAioVolume(ctx context.Context, in *GetAioVolumeRequest, opts ...grpc.CallOption) (*AioVolume, error)
	// Get an Aio Volume statistics
	StatsAioVolume(ctx context.Context, in *StatsAioVolumeRequest, opts ...grpc.CallOption) (*StatsAioVolumeResponse, error)
}

AioVolumeServiceClient is the client API for AioVolumeService 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 NewAioVolumeServiceClient 

func NewAioVolumeServiceClient(cc grpc.ClientConnInterface) AioVolumeServiceClient

type AioVolumeServiceServer 

type AioVolumeServiceServer interface {
	// Create an Aio Volume
	CreateAioVolume(context.Context, *CreateAioVolumeRequest) (*AioVolume, error)
	// Delete an Aio Volume
	DeleteAioVolume(context.Context, *DeleteAioVolumeRequest) (*emptypb.Empty, error)
	// Update an Aio Volume
	UpdateAioVolume(context.Context, *UpdateAioVolumeRequest) (*AioVolume, error)
	// List Aio Volumes
	ListAioVolumes(context.Context, *ListAioVolumesRequest) (*ListAioVolumesResponse, error)
	// Get an Aio Volume
	GetAioVolume(context.Context, *GetAioVolumeRequest) (*AioVolume, error)
	// Get an Aio Volume statistics
	StatsAioVolume(context.Context, *StatsAioVolumeRequest) (*StatsAioVolumeResponse, error)
	// contains filtered or unexported methods
}

AioVolumeServiceServer is the server API for AioVolumeService service. All implementations must embed UnimplementedAioVolumeServiceServer for forward compatibility

type CreateAioVolumeRequest 

type CreateAioVolumeRequest struct {

	// The Aio Volume to be created.
	AioVolume *AioVolume `protobuf:"bytes,1,opt,name=aio_volume,json=aioVolume,proto3" json:"aio_volume,omitempty"`
	// An optional ID to assign to the Aio Volume.
	// If this is not provided the system will auto-generate it.
	AioVolumeId string `protobuf:"bytes,2,opt,name=aio_volume_id,json=aioVolumeId,proto3" json:"aio_volume_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Aio Volume.

func (*CreateAioVolumeRequest) Descriptor deprecated 

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

Deprecated: Use CreateAioVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateAioVolumeRequest) GetAioVolume 

func (x *CreateAioVolumeRequest) GetAioVolume() *AioVolume

func (*CreateAioVolumeRequest) GetAioVolumeId 

func (x *CreateAioVolumeRequest) GetAioVolumeId() string

func (*CreateAioVolumeRequest) ProtoMessage 

func (*CreateAioVolumeRequest) ProtoMessage()

func (*CreateAioVolumeRequest) ProtoReflect 

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

func (*CreateAioVolumeRequest) Reset 

func (x *CreateAioVolumeRequest) Reset()

func (*CreateAioVolumeRequest) String 

func (x *CreateAioVolumeRequest) String() string

type CreateEncryptedVolumeRequest 

type CreateEncryptedVolumeRequest struct {

	// The Encrypted Volume to be created.
	EncryptedVolume *EncryptedVolume `protobuf:"bytes,1,opt,name=encrypted_volume,json=encryptedVolume,proto3" json:"encrypted_volume,omitempty"`
	// An optional ID to assign to the Encrypted Volume.
	// If this is not provided the system will auto-generate it.
	EncryptedVolumeId string `protobuf:"bytes,2,opt,name=encrypted_volume_id,json=encryptedVolumeId,proto3" json:"encrypted_volume_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Encrypted Volume.

func (*CreateEncryptedVolumeRequest) Descriptor deprecated 

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

Deprecated: Use CreateEncryptedVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateEncryptedVolumeRequest) GetEncryptedVolume 

func (x *CreateEncryptedVolumeRequest) GetEncryptedVolume() *EncryptedVolume

func (*CreateEncryptedVolumeRequest) GetEncryptedVolumeId 

func (x *CreateEncryptedVolumeRequest) GetEncryptedVolumeId() string

func (*CreateEncryptedVolumeRequest) ProtoMessage 

func (*CreateEncryptedVolumeRequest) ProtoMessage()

func (*CreateEncryptedVolumeRequest) ProtoReflect 

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

func (*CreateEncryptedVolumeRequest) Reset 

func (x *CreateEncryptedVolumeRequest) Reset()

func (*CreateEncryptedVolumeRequest) String 

func (x *CreateEncryptedVolumeRequest) String() string

type CreateMallocVolumeRequest 

type CreateMallocVolumeRequest struct {

	// The Malloc Volume to be created.
	MallocVolume *MallocVolume `protobuf:"bytes,1,opt,name=malloc_volume,json=mallocVolume,proto3" json:"malloc_volume,omitempty"`
	// An optional ID to assign to the Malloc Volume.
	// If this is not provided the system will auto-generate it.
	MallocVolumeId string `protobuf:"bytes,2,opt,name=malloc_volume_id,json=mallocVolumeId,proto3" json:"malloc_volume_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create a Malloc Volume.

func (*CreateMallocVolumeRequest) Descriptor deprecated 

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

Deprecated: Use CreateMallocVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateMallocVolumeRequest) GetMallocVolume 

func (x *CreateMallocVolumeRequest) GetMallocVolume() *MallocVolume

func (*CreateMallocVolumeRequest) GetMallocVolumeId 

func (x *CreateMallocVolumeRequest) GetMallocVolumeId() string

func (*CreateMallocVolumeRequest) ProtoMessage 

func (*CreateMallocVolumeRequest) ProtoMessage()

func (*CreateMallocVolumeRequest) ProtoReflect 

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

func (*CreateMallocVolumeRequest) Reset 

func (x *CreateMallocVolumeRequest) Reset()

func (*CreateMallocVolumeRequest) String 

func (x *CreateMallocVolumeRequest) String() string

type CreateNullVolumeRequest 

type CreateNullVolumeRequest struct {

	// The Null Volume to be created.
	NullVolume *NullVolume `protobuf:"bytes,1,opt,name=null_volume,json=nullVolume,proto3" json:"null_volume,omitempty"`
	// An optional ID to assign to the Null Volume.
	// If this is not provided the system will auto-generate it.
	NullVolumeId string `protobuf:"bytes,2,opt,name=null_volume_id,json=nullVolumeId,proto3" json:"null_volume_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Null Volume.

func (*CreateNullVolumeRequest) Descriptor deprecated 

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

Deprecated: Use CreateNullVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateNullVolumeRequest) GetNullVolume 

func (x *CreateNullVolumeRequest) GetNullVolume() *NullVolume

func (*CreateNullVolumeRequest) GetNullVolumeId 

func (x *CreateNullVolumeRequest) GetNullVolumeId() string

func (*CreateNullVolumeRequest) ProtoMessage 

func (*CreateNullVolumeRequest) ProtoMessage()

func (*CreateNullVolumeRequest) ProtoReflect 

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

func (*CreateNullVolumeRequest) Reset 

func (x *CreateNullVolumeRequest) Reset()

func (*CreateNullVolumeRequest) String 

func (x *CreateNullVolumeRequest) String() string

type CreateNvmeControllerRequest 

type CreateNvmeControllerRequest struct {

	// Parent's subsystem unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The Nvme Controller to be created
	NvmeController *NvmeController `protobuf:"bytes,2,opt,name=nvme_controller,json=nvmeController,proto3" json:"nvme_controller,omitempty"`
	// An optional ID to assign to the Nvme Controller.
	// If this is not provided the system will auto-generate it.
	NvmeControllerId string `protobuf:"bytes,3,opt,name=nvme_controller_id,json=nvmeControllerId,proto3" json:"nvme_controller_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Nvme Controller.

func (*CreateNvmeControllerRequest) Descriptor deprecated 

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

Deprecated: Use CreateNvmeControllerRequest.ProtoReflect.Descriptor instead.

func (*CreateNvmeControllerRequest) GetNvmeController 

func (x *CreateNvmeControllerRequest) GetNvmeController() *NvmeController

func (*CreateNvmeControllerRequest) GetNvmeControllerId 

func (x *CreateNvmeControllerRequest) GetNvmeControllerId() string

func (*CreateNvmeControllerRequest) GetParent 

func (x *CreateNvmeControllerRequest) GetParent() string

func (*CreateNvmeControllerRequest) ProtoMessage 

func (*CreateNvmeControllerRequest) ProtoMessage()

func (*CreateNvmeControllerRequest) ProtoReflect 

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

func (*CreateNvmeControllerRequest) Reset 

func (x *CreateNvmeControllerRequest) Reset()

func (*CreateNvmeControllerRequest) String 

func (x *CreateNvmeControllerRequest) String() string

type CreateNvmeNamespaceRequest 

type CreateNvmeNamespaceRequest struct {

	// Parent's subsystem unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The Nvme Namespace to be created
	NvmeNamespace *NvmeNamespace `protobuf:"bytes,2,opt,name=nvme_namespace,json=nvmeNamespace,proto3" json:"nvme_namespace,omitempty"`
	// An optional ID to assign to the Nvme Namespace.
	// If this is not provided the system will auto-generate it.
	NvmeNamespaceId string `protobuf:"bytes,3,opt,name=nvme_namespace_id,json=nvmeNamespaceId,proto3" json:"nvme_namespace_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Nvme Namespace.

func (*CreateNvmeNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use CreateNvmeNamespaceRequest.ProtoReflect.Descriptor instead.

func (*CreateNvmeNamespaceRequest) GetNvmeNamespace 

func (x *CreateNvmeNamespaceRequest) GetNvmeNamespace() *NvmeNamespace

func (*CreateNvmeNamespaceRequest) GetNvmeNamespaceId 

func (x *CreateNvmeNamespaceRequest) GetNvmeNamespaceId() string

func (*CreateNvmeNamespaceRequest) GetParent 

func (x *CreateNvmeNamespaceRequest) GetParent() string

func (*CreateNvmeNamespaceRequest) ProtoMessage 

func (*CreateNvmeNamespaceRequest) ProtoMessage()

func (*CreateNvmeNamespaceRequest) ProtoReflect 

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

func (*CreateNvmeNamespaceRequest) Reset 

func (x *CreateNvmeNamespaceRequest) Reset()

func (*CreateNvmeNamespaceRequest) String 

func (x *CreateNvmeNamespaceRequest) String() string

type CreateNvmePathRequest 

type CreateNvmePathRequest struct {

	// Parent's remote controller unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The Nvme Path to be created.
	NvmePath *NvmePath `protobuf:"bytes,2,opt,name=nvme_path,json=nvmePath,proto3" json:"nvme_path,omitempty"`
	// An optional ID to assign to the Nvme Path.
	// If this is not provided the system will auto-generate it.
	NvmePathId string `protobuf:"bytes,3,opt,name=nvme_path_id,json=nvmePathId,proto3" json:"nvme_path_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Nvme Path.

func (*CreateNvmePathRequest) Descriptor deprecated 

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

Deprecated: Use CreateNvmePathRequest.ProtoReflect.Descriptor instead.

func (*CreateNvmePathRequest) GetNvmePath 

func (x *CreateNvmePathRequest) GetNvmePath() *NvmePath

func (*CreateNvmePathRequest) GetNvmePathId 

func (x *CreateNvmePathRequest) GetNvmePathId() string

func (*CreateNvmePathRequest) GetParent 

func (x *CreateNvmePathRequest) GetParent() string

func (*CreateNvmePathRequest) ProtoMessage 

func (*CreateNvmePathRequest) ProtoMessage()

func (*CreateNvmePathRequest) ProtoReflect 

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

func (*CreateNvmePathRequest) Reset 

func (x *CreateNvmePathRequest) Reset()

func (*CreateNvmePathRequest) String 

func (x *CreateNvmePathRequest) String() string

type CreateNvmeRemoteControllerRequest 

type CreateNvmeRemoteControllerRequest struct {

	// The Nvme Remote Controller to be created.
	NvmeRemoteController *NvmeRemoteController `protobuf:"bytes,1,opt,name=nvme_remote_controller,json=nvmeRemoteController,proto3" json:"nvme_remote_controller,omitempty"`
	// An optional ID to assign to the Nvme Remote Controller.
	// If this is not provided the system will auto-generate it.
	NvmeRemoteControllerId string `` /* 131-byte string literal not displayed */
	// contains filtered or unexported fields
}

Represents a request to create an Nvme Remote Controller.

func (*CreateNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use CreateNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*CreateNvmeRemoteControllerRequest) GetNvmeRemoteController 

func (x *CreateNvmeRemoteControllerRequest) GetNvmeRemoteController() *NvmeRemoteController

func (*CreateNvmeRemoteControllerRequest) GetNvmeRemoteControllerId 

func (x *CreateNvmeRemoteControllerRequest) GetNvmeRemoteControllerId() string

func (*CreateNvmeRemoteControllerRequest) ProtoMessage 

func (*CreateNvmeRemoteControllerRequest) ProtoMessage()

func (*CreateNvmeRemoteControllerRequest) ProtoReflect 

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

func (*CreateNvmeRemoteControllerRequest) Reset 

func (x *CreateNvmeRemoteControllerRequest) Reset()

func (*CreateNvmeRemoteControllerRequest) String 

func (x *CreateNvmeRemoteControllerRequest) String() string

type CreateNvmeSubsystemRequest 

type CreateNvmeSubsystemRequest struct {

	// The Nvme Subsystem to be created.
	NvmeSubsystem *NvmeSubsystem `protobuf:"bytes,1,opt,name=nvme_subsystem,json=nvmeSubsystem,proto3" json:"nvme_subsystem,omitempty"`
	// An optional ID to assign to the Nvme Subsystem.
	// If this is not provided the system will auto-generate it.
	NvmeSubsystemId string `protobuf:"bytes,2,opt,name=nvme_subsystem_id,json=nvmeSubsystemId,proto3" json:"nvme_subsystem_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Nvme Subsystem.

func (*CreateNvmeSubsystemRequest) Descriptor deprecated 

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

Deprecated: Use CreateNvmeSubsystemRequest.ProtoReflect.Descriptor instead.

func (*CreateNvmeSubsystemRequest) GetNvmeSubsystem 

func (x *CreateNvmeSubsystemRequest) GetNvmeSubsystem() *NvmeSubsystem

func (*CreateNvmeSubsystemRequest) GetNvmeSubsystemId 

func (x *CreateNvmeSubsystemRequest) GetNvmeSubsystemId() string

func (*CreateNvmeSubsystemRequest) ProtoMessage 

func (*CreateNvmeSubsystemRequest) ProtoMessage()

func (*CreateNvmeSubsystemRequest) ProtoReflect 

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

func (*CreateNvmeSubsystemRequest) Reset 

func (x *CreateNvmeSubsystemRequest) Reset()

func (*CreateNvmeSubsystemRequest) String 

func (x *CreateNvmeSubsystemRequest) String() string

type CreateQosVolumeRequest 

type CreateQosVolumeRequest struct {

	// The QoS Volume to be created.
	QosVolume *QosVolume `protobuf:"bytes,1,opt,name=qos_volume,json=qosVolume,proto3" json:"qos_volume,omitempty"`
	// An optional ID to assign to the QoS Volume.
	// If this is not provided the system will auto-generate it.
	QosVolumeId string `protobuf:"bytes,2,opt,name=qos_volume_id,json=qosVolumeId,proto3" json:"qos_volume_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an QoS Volume.

func (*CreateQosVolumeRequest) Descriptor deprecated 

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

Deprecated: Use CreateQosVolumeRequest.ProtoReflect.Descriptor instead.

func (*CreateQosVolumeRequest) GetQosVolume 

func (x *CreateQosVolumeRequest) GetQosVolume() *QosVolume

func (*CreateQosVolumeRequest) GetQosVolumeId 

func (x *CreateQosVolumeRequest) GetQosVolumeId() string

func (*CreateQosVolumeRequest) ProtoMessage 

func (*CreateQosVolumeRequest) ProtoMessage()

func (*CreateQosVolumeRequest) ProtoReflect 

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

func (*CreateQosVolumeRequest) Reset 

func (x *CreateQosVolumeRequest) Reset()

func (*CreateQosVolumeRequest) String 

func (x *CreateQosVolumeRequest) String() string

type CreateVirtioBlkRequest 

type CreateVirtioBlkRequest struct {

	// The Virtio Blk to be created.
	VirtioBlk *VirtioBlk `protobuf:"bytes,1,opt,name=virtio_blk,json=virtioBlk,proto3" json:"virtio_blk,omitempty"`
	// An optional ID to assign to the Virtio Blk.
	// If this is not provided the system will auto-generate it.
	VirtioBlkId string `protobuf:"bytes,2,opt,name=virtio_blk_id,json=virtioBlkId,proto3" json:"virtio_blk_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Virtio Blk.

func (*CreateVirtioBlkRequest) Descriptor deprecated 

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

Deprecated: Use CreateVirtioBlkRequest.ProtoReflect.Descriptor instead.

func (*CreateVirtioBlkRequest) GetVirtioBlk 

func (x *CreateVirtioBlkRequest) GetVirtioBlk() *VirtioBlk

func (*CreateVirtioBlkRequest) GetVirtioBlkId 

func (x *CreateVirtioBlkRequest) GetVirtioBlkId() string

func (*CreateVirtioBlkRequest) ProtoMessage 

func (*CreateVirtioBlkRequest) ProtoMessage()

func (*CreateVirtioBlkRequest) ProtoReflect 

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

func (*CreateVirtioBlkRequest) Reset 

func (x *CreateVirtioBlkRequest) Reset()

func (*CreateVirtioBlkRequest) String 

func (x *CreateVirtioBlkRequest) String() string

type CreateVirtioScsiControllerRequest 

type CreateVirtioScsiControllerRequest struct {

	// The Virtio Scsi Controller to be created.
	VirtioScsiController *VirtioScsiController `protobuf:"bytes,1,opt,name=virtio_scsi_controller,json=virtioScsiController,proto3" json:"virtio_scsi_controller,omitempty"`
	// An optional ID to assign to the Virtio Scsi Controller.
	// If this is not provided the system will auto-generate it.
	VirtioScsiControllerId string `` /* 131-byte string literal not displayed */
	// contains filtered or unexported fields
}

Represents a request to create an Virtio Scsi Controller.

func (*CreateVirtioScsiControllerRequest) Descriptor deprecated 

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

Deprecated: Use CreateVirtioScsiControllerRequest.ProtoReflect.Descriptor instead.

func (*CreateVirtioScsiControllerRequest) GetVirtioScsiController 

func (x *CreateVirtioScsiControllerRequest) GetVirtioScsiController() *VirtioScsiController

func (*CreateVirtioScsiControllerRequest) GetVirtioScsiControllerId 

func (x *CreateVirtioScsiControllerRequest) GetVirtioScsiControllerId() string

func (*CreateVirtioScsiControllerRequest) ProtoMessage 

func (*CreateVirtioScsiControllerRequest) ProtoMessage()

func (*CreateVirtioScsiControllerRequest) ProtoReflect 

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

func (*CreateVirtioScsiControllerRequest) Reset 

func (x *CreateVirtioScsiControllerRequest) Reset()

func (*CreateVirtioScsiControllerRequest) String 

func (x *CreateVirtioScsiControllerRequest) String() string

type CreateVirtioScsiLunRequest 

type CreateVirtioScsiLunRequest struct {

	// The Virtio Scsi Lun to be created.
	VirtioScsiLun *VirtioScsiLun `protobuf:"bytes,1,opt,name=virtio_scsi_lun,json=virtioScsiLun,proto3" json:"virtio_scsi_lun,omitempty"`
	// An optional ID to assign to the Virtio Scsi Lun.
	// If this is not provided the system will auto-generate it.
	VirtioScsiLunId string `protobuf:"bytes,2,opt,name=virtio_scsi_lun_id,json=virtioScsiLunId,proto3" json:"virtio_scsi_lun_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Virtio Scsi Lun.

func (*CreateVirtioScsiLunRequest) Descriptor deprecated 

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

Deprecated: Use CreateVirtioScsiLunRequest.ProtoReflect.Descriptor instead.

func (*CreateVirtioScsiLunRequest) GetVirtioScsiLun 

func (x *CreateVirtioScsiLunRequest) GetVirtioScsiLun() *VirtioScsiLun

func (*CreateVirtioScsiLunRequest) GetVirtioScsiLunId 

func (x *CreateVirtioScsiLunRequest) GetVirtioScsiLunId() string

func (*CreateVirtioScsiLunRequest) ProtoMessage 

func (*CreateVirtioScsiLunRequest) ProtoMessage()

func (*CreateVirtioScsiLunRequest) ProtoReflect 

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

func (*CreateVirtioScsiLunRequest) Reset 

func (x *CreateVirtioScsiLunRequest) Reset()

func (*CreateVirtioScsiLunRequest) String 

func (x *CreateVirtioScsiLunRequest) String() string

type CreateVirtioScsiTargetRequest 

type CreateVirtioScsiTargetRequest struct {

	// The Virtio Scsi Target to be created.
	VirtioScsiTarget *VirtioScsiTarget `protobuf:"bytes,1,opt,name=virtio_scsi_target,json=virtioScsiTarget,proto3" json:"virtio_scsi_target,omitempty"`
	// An optional ID to assign to the Virtio Scsi Target.
	// If this is not provided the system will auto-generate it.
	VirtioScsiTargetId string `protobuf:"bytes,2,opt,name=virtio_scsi_target_id,json=virtioScsiTargetId,proto3" json:"virtio_scsi_target_id,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to create an Virtio Scsi Target.

func (*CreateVirtioScsiTargetRequest) Descriptor deprecated 

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

Deprecated: Use CreateVirtioScsiTargetRequest.ProtoReflect.Descriptor instead.

func (*CreateVirtioScsiTargetRequest) GetVirtioScsiTarget 

func (x *CreateVirtioScsiTargetRequest) GetVirtioScsiTarget() *VirtioScsiTarget

func (*CreateVirtioScsiTargetRequest) GetVirtioScsiTargetId 

func (x *CreateVirtioScsiTargetRequest) GetVirtioScsiTargetId() string

func (*CreateVirtioScsiTargetRequest) ProtoMessage 

func (*CreateVirtioScsiTargetRequest) ProtoMessage()

func (*CreateVirtioScsiTargetRequest) ProtoReflect 

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

func (*CreateVirtioScsiTargetRequest) Reset 

func (x *CreateVirtioScsiTargetRequest) Reset()

func (*CreateVirtioScsiTargetRequest) String 

func (x *CreateVirtioScsiTargetRequest) String() string

type DeleteAioVolumeRequest 

type DeleteAioVolumeRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Aio Volume.

func (*DeleteAioVolumeRequest) Descriptor deprecated 

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

Deprecated: Use DeleteAioVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteAioVolumeRequest) GetAllowMissing 

func (x *DeleteAioVolumeRequest) GetAllowMissing() bool

func (*DeleteAioVolumeRequest) GetName 

func (x *DeleteAioVolumeRequest) GetName() string

func (*DeleteAioVolumeRequest) ProtoMessage 

func (*DeleteAioVolumeRequest) ProtoMessage()

func (*DeleteAioVolumeRequest) ProtoReflect 

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

func (*DeleteAioVolumeRequest) Reset 

func (x *DeleteAioVolumeRequest) Reset()

func (*DeleteAioVolumeRequest) String 

func (x *DeleteAioVolumeRequest) String() string

type DeleteEncryptedVolumeRequest 

type DeleteEncryptedVolumeRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Encrypted Volume.

func (*DeleteEncryptedVolumeRequest) Descriptor deprecated 

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

Deprecated: Use DeleteEncryptedVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteEncryptedVolumeRequest) GetAllowMissing 

func (x *DeleteEncryptedVolumeRequest) GetAllowMissing() bool

func (*DeleteEncryptedVolumeRequest) GetName 

func (x *DeleteEncryptedVolumeRequest) GetName() string

func (*DeleteEncryptedVolumeRequest) ProtoMessage 

func (*DeleteEncryptedVolumeRequest) ProtoMessage()

func (*DeleteEncryptedVolumeRequest) ProtoReflect 

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

func (*DeleteEncryptedVolumeRequest) Reset 

func (x *DeleteEncryptedVolumeRequest) Reset()

func (*DeleteEncryptedVolumeRequest) String 

func (x *DeleteEncryptedVolumeRequest) String() string

type DeleteMallocVolumeRequest 

type DeleteMallocVolumeRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete a Malloc Volume.

func (*DeleteMallocVolumeRequest) Descriptor deprecated 

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

Deprecated: Use DeleteMallocVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteMallocVolumeRequest) GetAllowMissing 

func (x *DeleteMallocVolumeRequest) GetAllowMissing() bool

func (*DeleteMallocVolumeRequest) GetName 

func (x *DeleteMallocVolumeRequest) GetName() string

func (*DeleteMallocVolumeRequest) ProtoMessage 

func (*DeleteMallocVolumeRequest) ProtoMessage()

func (*DeleteMallocVolumeRequest) ProtoReflect 

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

func (*DeleteMallocVolumeRequest) Reset 

func (x *DeleteMallocVolumeRequest) Reset()

func (*DeleteMallocVolumeRequest) String 

func (x *DeleteMallocVolumeRequest) String() string

type DeleteNullVolumeRequest 

type DeleteNullVolumeRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Null Volume.

func (*DeleteNullVolumeRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNullVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteNullVolumeRequest) GetAllowMissing 

func (x *DeleteNullVolumeRequest) GetAllowMissing() bool

func (*DeleteNullVolumeRequest) GetName 

func (x *DeleteNullVolumeRequest) GetName() string

func (*DeleteNullVolumeRequest) ProtoMessage 

func (*DeleteNullVolumeRequest) ProtoMessage()

func (*DeleteNullVolumeRequest) ProtoReflect 

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

func (*DeleteNullVolumeRequest) Reset 

func (x *DeleteNullVolumeRequest) Reset()

func (*DeleteNullVolumeRequest) String 

func (x *DeleteNullVolumeRequest) String() string

type DeleteNvmeControllerRequest 

type DeleteNvmeControllerRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Nvme Controller.

func (*DeleteNvmeControllerRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNvmeControllerRequest.ProtoReflect.Descriptor instead.

func (*DeleteNvmeControllerRequest) GetAllowMissing 

func (x *DeleteNvmeControllerRequest) GetAllowMissing() bool

func (*DeleteNvmeControllerRequest) GetName 

func (x *DeleteNvmeControllerRequest) GetName() string

func (*DeleteNvmeControllerRequest) ProtoMessage 

func (*DeleteNvmeControllerRequest) ProtoMessage()

func (*DeleteNvmeControllerRequest) ProtoReflect 

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

func (*DeleteNvmeControllerRequest) Reset 

func (x *DeleteNvmeControllerRequest) Reset()

func (*DeleteNvmeControllerRequest) String 

func (x *DeleteNvmeControllerRequest) String() string

type DeleteNvmeNamespaceRequest 

type DeleteNvmeNamespaceRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Nvme Namespace.

func (*DeleteNvmeNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNvmeNamespaceRequest.ProtoReflect.Descriptor instead.

func (*DeleteNvmeNamespaceRequest) GetAllowMissing 

func (x *DeleteNvmeNamespaceRequest) GetAllowMissing() bool

func (*DeleteNvmeNamespaceRequest) GetName 

func (x *DeleteNvmeNamespaceRequest) GetName() string

func (*DeleteNvmeNamespaceRequest) ProtoMessage 

func (*DeleteNvmeNamespaceRequest) ProtoMessage()

func (*DeleteNvmeNamespaceRequest) ProtoReflect 

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

func (*DeleteNvmeNamespaceRequest) Reset 

func (x *DeleteNvmeNamespaceRequest) Reset()

func (*DeleteNvmeNamespaceRequest) String 

func (x *DeleteNvmeNamespaceRequest) String() string

type DeleteNvmePathRequest 

type DeleteNvmePathRequest struct {

	// object's unique identifier
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Nvme Path.

func (*DeleteNvmePathRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNvmePathRequest.ProtoReflect.Descriptor instead.

func (*DeleteNvmePathRequest) GetAllowMissing 

func (x *DeleteNvmePathRequest) GetAllowMissing() bool

func (*DeleteNvmePathRequest) GetName 

func (x *DeleteNvmePathRequest) GetName() string

func (*DeleteNvmePathRequest) ProtoMessage 

func (*DeleteNvmePathRequest) ProtoMessage()

func (*DeleteNvmePathRequest) ProtoReflect 

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

func (*DeleteNvmePathRequest) Reset 

func (x *DeleteNvmePathRequest) Reset()

func (*DeleteNvmePathRequest) String 

func (x *DeleteNvmePathRequest) String() string

type DeleteNvmeRemoteControllerRequest 

type DeleteNvmeRemoteControllerRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

(-- api-linter: core::0135::force-field=disabled 

aip.dev/not-precedent: disabled since cascade deleting is a dangerous
                       operation and we want to force a user to delete
                       all child resources(paths) on
                       its own --)

Represents a request to delete an Nvme Remote Controller.

func (*DeleteNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*DeleteNvmeRemoteControllerRequest) GetAllowMissing 

func (x *DeleteNvmeRemoteControllerRequest) GetAllowMissing() bool

func (*DeleteNvmeRemoteControllerRequest) GetName 

func (x *DeleteNvmeRemoteControllerRequest) GetName() string

func (*DeleteNvmeRemoteControllerRequest) ProtoMessage 

func (*DeleteNvmeRemoteControllerRequest) ProtoMessage()

func (*DeleteNvmeRemoteControllerRequest) ProtoReflect 

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

func (*DeleteNvmeRemoteControllerRequest) Reset 

func (x *DeleteNvmeRemoteControllerRequest) Reset()

func (*DeleteNvmeRemoteControllerRequest) String 

func (x *DeleteNvmeRemoteControllerRequest) String() string

type DeleteNvmeSubsystemRequest 

type DeleteNvmeSubsystemRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

(-- api-linter: core::0135::force-field=disabled 

aip.dev/not-precedent: disabled since cascade deleting is a dangerous
                       operation and we want to force a user to delete
                       all child resources(controllers and namespaces) on
                       its own --)

Represents a request to delete an Nvme Subsystem.

func (*DeleteNvmeSubsystemRequest) Descriptor deprecated 

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

Deprecated: Use DeleteNvmeSubsystemRequest.ProtoReflect.Descriptor instead.

func (*DeleteNvmeSubsystemRequest) GetAllowMissing 

func (x *DeleteNvmeSubsystemRequest) GetAllowMissing() bool

func (*DeleteNvmeSubsystemRequest) GetName 

func (x *DeleteNvmeSubsystemRequest) GetName() string

func (*DeleteNvmeSubsystemRequest) ProtoMessage 

func (*DeleteNvmeSubsystemRequest) ProtoMessage()

func (*DeleteNvmeSubsystemRequest) ProtoReflect 

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

func (*DeleteNvmeSubsystemRequest) Reset 

func (x *DeleteNvmeSubsystemRequest) Reset()

func (*DeleteNvmeSubsystemRequest) String 

func (x *DeleteNvmeSubsystemRequest) String() string

type DeleteQosVolumeRequest 

type DeleteQosVolumeRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an QoS Volume.

func (*DeleteQosVolumeRequest) Descriptor deprecated 

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

Deprecated: Use DeleteQosVolumeRequest.ProtoReflect.Descriptor instead.

func (*DeleteQosVolumeRequest) GetAllowMissing 

func (x *DeleteQosVolumeRequest) GetAllowMissing() bool

func (*DeleteQosVolumeRequest) GetName 

func (x *DeleteQosVolumeRequest) GetName() string

func (*DeleteQosVolumeRequest) ProtoMessage 

func (*DeleteQosVolumeRequest) ProtoMessage()

func (*DeleteQosVolumeRequest) ProtoReflect 

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

func (*DeleteQosVolumeRequest) Reset 

func (x *DeleteQosVolumeRequest) Reset()

func (*DeleteQosVolumeRequest) String 

func (x *DeleteQosVolumeRequest) String() string

type DeleteVirtioBlkRequest 

type DeleteVirtioBlkRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Virtio Blk.

func (*DeleteVirtioBlkRequest) Descriptor deprecated 

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

Deprecated: Use DeleteVirtioBlkRequest.ProtoReflect.Descriptor instead.

func (*DeleteVirtioBlkRequest) GetAllowMissing 

func (x *DeleteVirtioBlkRequest) GetAllowMissing() bool

func (*DeleteVirtioBlkRequest) GetName 

func (x *DeleteVirtioBlkRequest) GetName() string

func (*DeleteVirtioBlkRequest) ProtoMessage 

func (*DeleteVirtioBlkRequest) ProtoMessage()

func (*DeleteVirtioBlkRequest) ProtoReflect 

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

func (*DeleteVirtioBlkRequest) Reset 

func (x *DeleteVirtioBlkRequest) Reset()

func (*DeleteVirtioBlkRequest) String 

func (x *DeleteVirtioBlkRequest) String() string

type DeleteVirtioScsiControllerRequest 

type DeleteVirtioScsiControllerRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Virtio Scsi Controller.

func (*DeleteVirtioScsiControllerRequest) Descriptor deprecated 

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

Deprecated: Use DeleteVirtioScsiControllerRequest.ProtoReflect.Descriptor instead.

func (*DeleteVirtioScsiControllerRequest) GetAllowMissing 

func (x *DeleteVirtioScsiControllerRequest) GetAllowMissing() bool

func (*DeleteVirtioScsiControllerRequest) GetName 

func (x *DeleteVirtioScsiControllerRequest) GetName() string

func (*DeleteVirtioScsiControllerRequest) ProtoMessage 

func (*DeleteVirtioScsiControllerRequest) ProtoMessage()

func (*DeleteVirtioScsiControllerRequest) ProtoReflect 

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

func (*DeleteVirtioScsiControllerRequest) Reset 

func (x *DeleteVirtioScsiControllerRequest) Reset()

func (*DeleteVirtioScsiControllerRequest) String 

func (x *DeleteVirtioScsiControllerRequest) String() string

type DeleteVirtioScsiLunRequest 

type DeleteVirtioScsiLunRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Virtio Scsi Lun.

func (*DeleteVirtioScsiLunRequest) Descriptor deprecated 

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

Deprecated: Use DeleteVirtioScsiLunRequest.ProtoReflect.Descriptor instead.

func (*DeleteVirtioScsiLunRequest) GetAllowMissing 

func (x *DeleteVirtioScsiLunRequest) GetAllowMissing() bool

func (*DeleteVirtioScsiLunRequest) GetName 

func (x *DeleteVirtioScsiLunRequest) GetName() string

func (*DeleteVirtioScsiLunRequest) ProtoMessage 

func (*DeleteVirtioScsiLunRequest) ProtoMessage()

func (*DeleteVirtioScsiLunRequest) ProtoReflect 

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

func (*DeleteVirtioScsiLunRequest) Reset 

func (x *DeleteVirtioScsiLunRequest) Reset()

func (*DeleteVirtioScsiLunRequest) String 

func (x *DeleteVirtioScsiLunRequest) String() string

type DeleteVirtioScsiTargetRequest 

type DeleteVirtioScsiTargetRequest struct {

	// Object's unique identifier to delete
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If set to true, and the resource is not found, the request will succeed
	// but no action will be taken on the server
	AllowMissing bool `protobuf:"varint,2,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to delete an Virtio Scsi Target.

func (*DeleteVirtioScsiTargetRequest) Descriptor deprecated 

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

Deprecated: Use DeleteVirtioScsiTargetRequest.ProtoReflect.Descriptor instead.

func (*DeleteVirtioScsiTargetRequest) GetAllowMissing 

func (x *DeleteVirtioScsiTargetRequest) GetAllowMissing() bool

func (*DeleteVirtioScsiTargetRequest) GetName 

func (x *DeleteVirtioScsiTargetRequest) GetName() string

func (*DeleteVirtioScsiTargetRequest) ProtoMessage 

func (*DeleteVirtioScsiTargetRequest) ProtoMessage()

func (*DeleteVirtioScsiTargetRequest) ProtoReflect 

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

func (*DeleteVirtioScsiTargetRequest) Reset 

func (x *DeleteVirtioScsiTargetRequest) Reset()

func (*DeleteVirtioScsiTargetRequest) String 

func (x *DeleteVirtioScsiTargetRequest) String() string

type EncryptedVolume 

type EncryptedVolume struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The back/middle-end volume to back this volume
	VolumeNameRef string `protobuf:"bytes,2,opt,name=volume_name_ref,json=volumeNameRef,proto3" json:"volume_name_ref,omitempty"`
	// Key to be used for encryption
	Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	// Cipher to use
	Cipher EncryptionType `protobuf:"varint,4,opt,name=cipher,proto3,enum=opi_api.storage.v1.EncryptionType" json:"cipher,omitempty"`
	// contains filtered or unexported fields
}

Represents volume encrypting IOs

func (*EncryptedVolume) Descriptor deprecated 

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

Deprecated: Use EncryptedVolume.ProtoReflect.Descriptor instead.

func (*EncryptedVolume) GetCipher 

func (x *EncryptedVolume) GetCipher() EncryptionType

func (*EncryptedVolume) GetKey 

func (x *EncryptedVolume) GetKey() []byte

func (*EncryptedVolume) GetName 

func (x *EncryptedVolume) GetName() string

func (*EncryptedVolume) GetVolumeNameRef 

func (x *EncryptedVolume) GetVolumeNameRef() string

func (*EncryptedVolume) ProtoMessage 

func (*EncryptedVolume) ProtoMessage()

func (*EncryptedVolume) ProtoReflect 

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

func (*EncryptedVolume) Reset 

func (x *EncryptedVolume) Reset()

func (*EncryptedVolume) String 

func (x *EncryptedVolume) String() string

type EncryptionType 

type EncryptionType int32

AES encryption types 

const (
	// Encryption type is not specified
	EncryptionType_ENCRYPTION_TYPE_UNSPECIFIED EncryptionType = 0
	// AES CBC 128 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_CBC_128 EncryptionType = 1
	// AES CBC 192 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_CBC_192 EncryptionType = 2
	// AES CBC 256 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_CBC_256 EncryptionType = 3
	// AES XTS 128 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_XTS_128 EncryptionType = 4
	// AES XTS 192 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_XTS_192 EncryptionType = 5
	// AES XTS 256 encryption type
	EncryptionType_ENCRYPTION_TYPE_AES_XTS_256 EncryptionType = 6
)

func (EncryptionType) Descriptor 

func (EncryptionType) Descriptor() protoreflect.EnumDescriptor

func (EncryptionType) Enum 

func (x EncryptionType) Enum() *EncryptionType

func (EncryptionType) EnumDescriptor deprecated 

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

Deprecated: Use EncryptionType.Descriptor instead.

func (EncryptionType) Number 

func (x EncryptionType) Number() protoreflect.EnumNumber

func (EncryptionType) String 

func (x EncryptionType) String() string

func (EncryptionType) Type 

func (EncryptionType) Type() protoreflect.EnumType

type FabricsEndpoint 

type FabricsEndpoint struct {

	// ip address for TCP and RDMA
	Traddr string `protobuf:"bytes,1,opt,name=traddr,proto3" json:"traddr,omitempty"`
	// port for TCP and RDMA
	Trsvcid string `protobuf:"bytes,2,opt,name=trsvcid,proto3" json:"trsvcid,omitempty"`
	// address family
	Adrfam NvmeAddressFamily `protobuf:"varint,3,opt,name=adrfam,proto3,enum=opi_api.storage.v1.NvmeAddressFamily" json:"adrfam,omitempty"`
	// contains filtered or unexported fields
}

Represents Fabrics Endpoint

func (*FabricsEndpoint) Descriptor deprecated 

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

Deprecated: Use FabricsEndpoint.ProtoReflect.Descriptor instead.

func (*FabricsEndpoint) GetAdrfam 

func (x *FabricsEndpoint) GetAdrfam() NvmeAddressFamily

func (*FabricsEndpoint) GetTraddr 

func (x *FabricsEndpoint) GetTraddr() string

func (*FabricsEndpoint) GetTrsvcid 

func (x *FabricsEndpoint) GetTrsvcid() string

func (*FabricsEndpoint) ProtoMessage 

func (*FabricsEndpoint) ProtoMessage()

func (*FabricsEndpoint) ProtoReflect 

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

func (*FabricsEndpoint) Reset 

func (x *FabricsEndpoint) Reset()

func (*FabricsEndpoint) String 

func (x *FabricsEndpoint) String() string

type FabricsPath 

type FabricsPath struct {

	// Destination service id (e.g. Port)
	Trsvcid int64 `protobuf:"varint,1,opt,name=trsvcid,proto3" json:"trsvcid,omitempty"`
	// Subsystem NQN
	Subnqn string `protobuf:"bytes,2,opt,name=subnqn,proto3" json:"subnqn,omitempty"`
	// Address family
	Adrfam NvmeAddressFamily `protobuf:"varint,3,opt,name=adrfam,proto3,enum=opi_api.storage.v1.NvmeAddressFamily" json:"adrfam,omitempty"`
	// Source address (e.g. IP of local NIC)
	SourceTraddr string `protobuf:"bytes,4,opt,name=source_traddr,json=sourceTraddr,proto3" json:"source_traddr,omitempty"`
	// Source port (e.g. Port of local NIC)
	SourceTrsvcid int64 `protobuf:"varint,5,opt,name=source_trsvcid,json=sourceTrsvcid,proto3" json:"source_trsvcid,omitempty"`
	// Host NQN
	Hostnqn string `protobuf:"bytes,6,opt,name=hostnqn,proto3" json:"hostnqn,omitempty"`
	// contains filtered or unexported fields
}

Represents Fabrics transport path parameters

func (*FabricsPath) Descriptor deprecated 

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

Deprecated: Use FabricsPath.ProtoReflect.Descriptor instead.

func (*FabricsPath) GetAdrfam 

func (x *FabricsPath) GetAdrfam() NvmeAddressFamily

func (*FabricsPath) GetHostnqn 

func (x *FabricsPath) GetHostnqn() string

func (*FabricsPath) GetSourceTraddr 

func (x *FabricsPath) GetSourceTraddr() string

func (*FabricsPath) GetSourceTrsvcid 

func (x *FabricsPath) GetSourceTrsvcid() int64

func (*FabricsPath) GetSubnqn 

func (x *FabricsPath) GetSubnqn() string

func (*FabricsPath) GetTrsvcid 

func (x *FabricsPath) GetTrsvcid() int64

func (*FabricsPath) ProtoMessage 

func (*FabricsPath) ProtoMessage()

func (*FabricsPath) ProtoReflect 

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

func (*FabricsPath) Reset 

func (x *FabricsPath) Reset()

func (*FabricsPath) String 

func (x *FabricsPath) String() string

type FrontendNvmeServiceClient 

type FrontendNvmeServiceClient interface {
	// Create an Nvme Subsystem
	CreateNvmeSubsystem(ctx context.Context, in *CreateNvmeSubsystemRequest, opts ...grpc.CallOption) (*NvmeSubsystem, error)
	// Delete an Nvme Subsystem
	// Fails if there are any associated objects
	DeleteNvmeSubsystem(ctx context.Context, in *DeleteNvmeSubsystemRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Nvme Subsystem
	UpdateNvmeSubsystem(ctx context.Context, in *UpdateNvmeSubsystemRequest, opts ...grpc.CallOption) (*NvmeSubsystem, error)
	// List Nvme Subsystems
	ListNvmeSubsystems(ctx context.Context, in *ListNvmeSubsystemsRequest, opts ...grpc.CallOption) (*ListNvmeSubsystemsResponse, error)
	// Get an Nvme Subsystem
	GetNvmeSubsystem(ctx context.Context, in *GetNvmeSubsystemRequest, opts ...grpc.CallOption) (*NvmeSubsystem, error)
	// Get an Nvme Subsystem statistics
	StatsNvmeSubsystem(ctx context.Context, in *StatsNvmeSubsystemRequest, opts ...grpc.CallOption) (*StatsNvmeSubsystemResponse, error)
	// Create an Nvme Controller
	CreateNvmeController(ctx context.Context, in *CreateNvmeControllerRequest, opts ...grpc.CallOption) (*NvmeController, error)
	// Delete an Nvme Controller
	// Fails if there are any associated objects
	DeleteNvmeController(ctx context.Context, in *DeleteNvmeControllerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Nvme Controller
	UpdateNvmeController(ctx context.Context, in *UpdateNvmeControllerRequest, opts ...grpc.CallOption) (*NvmeController, error)
	// List Nvme Controllers
	ListNvmeControllers(ctx context.Context, in *ListNvmeControllersRequest, opts ...grpc.CallOption) (*ListNvmeControllersResponse, error)
	// Get an Nvme Controller
	GetNvmeController(ctx context.Context, in *GetNvmeControllerRequest, opts ...grpc.CallOption) (*NvmeController, error)
	// Get an Nvme Controller statistics
	StatsNvmeController(ctx context.Context, in *StatsNvmeControllerRequest, opts ...grpc.CallOption) (*StatsNvmeControllerResponse, error)
	// Create an Nvme Namespace
	CreateNvmeNamespace(ctx context.Context, in *CreateNvmeNamespaceRequest, opts ...grpc.CallOption) (*NvmeNamespace, error)
	// Delete an Nvme Namespace
	DeleteNvmeNamespace(ctx context.Context, in *DeleteNvmeNamespaceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Nvme Namespace
	UpdateNvmeNamespace(ctx context.Context, in *UpdateNvmeNamespaceRequest, opts ...grpc.CallOption) (*NvmeNamespace, error)
	// List Nvme Namespaces
	ListNvmeNamespaces(ctx context.Context, in *ListNvmeNamespacesRequest, opts ...grpc.CallOption) (*ListNvmeNamespacesResponse, error)
	// Get an Nvme Namespace
	GetNvmeNamespace(ctx context.Context, in *GetNvmeNamespaceRequest, opts ...grpc.CallOption) (*NvmeNamespace, error)
	// Get an Nvme Namespace statistics
	StatsNvmeNamespace(ctx context.Context, in *StatsNvmeNamespaceRequest, opts ...grpc.CallOption) (*StatsNvmeNamespaceResponse, error)
}

FrontendNvmeServiceClient is the client API for FrontendNvmeService 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 NewFrontendNvmeServiceClient 

func NewFrontendNvmeServiceClient(cc grpc.ClientConnInterface) FrontendNvmeServiceClient

type FrontendNvmeServiceServer 

type FrontendNvmeServiceServer interface {
	// Create an Nvme Subsystem
	CreateNvmeSubsystem(context.Context, *CreateNvmeSubsystemRequest) (*NvmeSubsystem, error)
	// Delete an Nvme Subsystem
	// Fails if there are any associated objects
	DeleteNvmeSubsystem(context.Context, *DeleteNvmeSubsystemRequest) (*emptypb.Empty, error)
	// Update an Nvme Subsystem
	UpdateNvmeSubsystem(context.Context, *UpdateNvmeSubsystemRequest) (*NvmeSubsystem, error)
	// List Nvme Subsystems
	ListNvmeSubsystems(context.Context, *ListNvmeSubsystemsRequest) (*ListNvmeSubsystemsResponse, error)
	// Get an Nvme Subsystem
	GetNvmeSubsystem(context.Context, *GetNvmeSubsystemRequest) (*NvmeSubsystem, error)
	// Get an Nvme Subsystem statistics
	StatsNvmeSubsystem(context.Context, *StatsNvmeSubsystemRequest) (*StatsNvmeSubsystemResponse, error)
	// Create an Nvme Controller
	CreateNvmeController(context.Context, *CreateNvmeControllerRequest) (*NvmeController, error)
	// Delete an Nvme Controller
	// Fails if there are any associated objects
	DeleteNvmeController(context.Context, *DeleteNvmeControllerRequest) (*emptypb.Empty, error)
	// Update an Nvme Controller
	UpdateNvmeController(context.Context, *UpdateNvmeControllerRequest) (*NvmeController, error)
	// List Nvme Controllers
	ListNvmeControllers(context.Context, *ListNvmeControllersRequest) (*ListNvmeControllersResponse, error)
	// Get an Nvme Controller
	GetNvmeController(context.Context, *GetNvmeControllerRequest) (*NvmeController, error)
	// Get an Nvme Controller statistics
	StatsNvmeController(context.Context, *StatsNvmeControllerRequest) (*StatsNvmeControllerResponse, error)
	// Create an Nvme Namespace
	CreateNvmeNamespace(context.Context, *CreateNvmeNamespaceRequest) (*NvmeNamespace, error)
	// Delete an Nvme Namespace
	DeleteNvmeNamespace(context.Context, *DeleteNvmeNamespaceRequest) (*emptypb.Empty, error)
	// Update an Nvme Namespace
	UpdateNvmeNamespace(context.Context, *UpdateNvmeNamespaceRequest) (*NvmeNamespace, error)
	// List Nvme Namespaces
	ListNvmeNamespaces(context.Context, *ListNvmeNamespacesRequest) (*ListNvmeNamespacesResponse, error)
	// Get an Nvme Namespace
	GetNvmeNamespace(context.Context, *GetNvmeNamespaceRequest) (*NvmeNamespace, error)
	// Get an Nvme Namespace statistics
	StatsNvmeNamespace(context.Context, *StatsNvmeNamespaceRequest) (*StatsNvmeNamespaceResponse, error)
	// contains filtered or unexported methods
}

FrontendNvmeServiceServer is the server API for FrontendNvmeService service. All implementations must embed UnimplementedFrontendNvmeServiceServer for forward compatibility

type FrontendVirtioBlkServiceClient 

type FrontendVirtioBlkServiceClient interface {
	// Create an Virtio Blk
	CreateVirtioBlk(ctx context.Context, in *CreateVirtioBlkRequest, opts ...grpc.CallOption) (*VirtioBlk, error)
	// Delete an Virtio Blk
	DeleteVirtioBlk(ctx context.Context, in *DeleteVirtioBlkRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Virtio Blk
	UpdateVirtioBlk(ctx context.Context, in *UpdateVirtioBlkRequest, opts ...grpc.CallOption) (*VirtioBlk, error)
	// List Virtio Blks
	ListVirtioBlks(ctx context.Context, in *ListVirtioBlksRequest, opts ...grpc.CallOption) (*ListVirtioBlksResponse, error)
	// Get an Virtio Blk
	GetVirtioBlk(ctx context.Context, in *GetVirtioBlkRequest, opts ...grpc.CallOption) (*VirtioBlk, error)
	// Get an Virtio Blk statistics
	StatsVirtioBlk(ctx context.Context, in *StatsVirtioBlkRequest, opts ...grpc.CallOption) (*StatsVirtioBlkResponse, error)
}

FrontendVirtioBlkServiceClient is the client API for FrontendVirtioBlkService 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 NewFrontendVirtioBlkServiceClient 

func NewFrontendVirtioBlkServiceClient(cc grpc.ClientConnInterface) FrontendVirtioBlkServiceClient

type FrontendVirtioBlkServiceServer 

type FrontendVirtioBlkServiceServer interface {
	// Create an Virtio Blk
	CreateVirtioBlk(context.Context, *CreateVirtioBlkRequest) (*VirtioBlk, error)
	// Delete an Virtio Blk
	DeleteVirtioBlk(context.Context, *DeleteVirtioBlkRequest) (*emptypb.Empty, error)
	// Update an Virtio Blk
	UpdateVirtioBlk(context.Context, *UpdateVirtioBlkRequest) (*VirtioBlk, error)
	// List Virtio Blks
	ListVirtioBlks(context.Context, *ListVirtioBlksRequest) (*ListVirtioBlksResponse, error)
	// Get an Virtio Blk
	GetVirtioBlk(context.Context, *GetVirtioBlkRequest) (*VirtioBlk, error)
	// Get an Virtio Blk statistics
	StatsVirtioBlk(context.Context, *StatsVirtioBlkRequest) (*StatsVirtioBlkResponse, error)
	// contains filtered or unexported methods
}

FrontendVirtioBlkServiceServer is the server API for FrontendVirtioBlkService service. All implementations must embed UnimplementedFrontendVirtioBlkServiceServer for forward compatibility

type FrontendVirtioScsiServiceClient 

type FrontendVirtioScsiServiceClient interface {
	// Create an Virtio Scsi Target
	CreateVirtioScsiTarget(ctx context.Context, in *CreateVirtioScsiTargetRequest, opts ...grpc.CallOption) (*VirtioScsiTarget, error)
	// Delete an Virtio Scsi Target
	DeleteVirtioScsiTarget(ctx context.Context, in *DeleteVirtioScsiTargetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Virtio Scsi Target
	UpdateVirtioScsiTarget(ctx context.Context, in *UpdateVirtioScsiTargetRequest, opts ...grpc.CallOption) (*VirtioScsiTarget, error)
	// List Virtio Scsi Targets
	ListVirtioScsiTargets(ctx context.Context, in *ListVirtioScsiTargetsRequest, opts ...grpc.CallOption) (*ListVirtioScsiTargetsResponse, error)
	// Get an Virtio Scsi Target
	GetVirtioScsiTarget(ctx context.Context, in *GetVirtioScsiTargetRequest, opts ...grpc.CallOption) (*VirtioScsiTarget, error)
	// Get an Virtio Scsi Target statistics
	StatsVirtioScsiTarget(ctx context.Context, in *StatsVirtioScsiTargetRequest, opts ...grpc.CallOption) (*StatsVirtioScsiTargetResponse, error)
	// Create an Virtio Scsi Controller
	CreateVirtioScsiController(ctx context.Context, in *CreateVirtioScsiControllerRequest, opts ...grpc.CallOption) (*VirtioScsiController, error)
	// Delete an Virtio Scsi Controller
	DeleteVirtioScsiController(ctx context.Context, in *DeleteVirtioScsiControllerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Virtio Scsi Controller
	UpdateVirtioScsiController(ctx context.Context, in *UpdateVirtioScsiControllerRequest, opts ...grpc.CallOption) (*VirtioScsiController, error)
	// List Virtio Scsi Controllers
	ListVirtioScsiControllers(ctx context.Context, in *ListVirtioScsiControllersRequest, opts ...grpc.CallOption) (*ListVirtioScsiControllersResponse, error)
	// Get an Virtio Scsi Controller
	GetVirtioScsiController(ctx context.Context, in *GetVirtioScsiControllerRequest, opts ...grpc.CallOption) (*VirtioScsiController, error)
	// Get an Virtio Scsi Controller statistics
	StatsVirtioScsiController(ctx context.Context, in *StatsVirtioScsiControllerRequest, opts ...grpc.CallOption) (*StatsVirtioScsiControllerResponse, error)
	// Create an Virtio Scsi Lun
	CreateVirtioScsiLun(ctx context.Context, in *CreateVirtioScsiLunRequest, opts ...grpc.CallOption) (*VirtioScsiLun, error)
	// Delete an Virtio Scsi Lun
	DeleteVirtioScsiLun(ctx context.Context, in *DeleteVirtioScsiLunRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Virtio Scsi Lun
	UpdateVirtioScsiLun(ctx context.Context, in *UpdateVirtioScsiLunRequest, opts ...grpc.CallOption) (*VirtioScsiLun, error)
	// List Virtio Scsi Luns
	ListVirtioScsiLuns(ctx context.Context, in *ListVirtioScsiLunsRequest, opts ...grpc.CallOption) (*ListVirtioScsiLunsResponse, error)
	// Get an Virtio Scsi Lun
	GetVirtioScsiLun(ctx context.Context, in *GetVirtioScsiLunRequest, opts ...grpc.CallOption) (*VirtioScsiLun, error)
	// Get an Virtio Scsi Lun statistics
	StatsVirtioScsiLun(ctx context.Context, in *StatsVirtioScsiLunRequest, opts ...grpc.CallOption) (*StatsVirtioScsiLunResponse, error)
}

FrontendVirtioScsiServiceClient is the client API for FrontendVirtioScsiService 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 NewFrontendVirtioScsiServiceClient 

func NewFrontendVirtioScsiServiceClient(cc grpc.ClientConnInterface) FrontendVirtioScsiServiceClient

type FrontendVirtioScsiServiceServer 

type FrontendVirtioScsiServiceServer interface {
	// Create an Virtio Scsi Target
	CreateVirtioScsiTarget(context.Context, *CreateVirtioScsiTargetRequest) (*VirtioScsiTarget, error)
	// Delete an Virtio Scsi Target
	DeleteVirtioScsiTarget(context.Context, *DeleteVirtioScsiTargetRequest) (*emptypb.Empty, error)
	// Update an Virtio Scsi Target
	UpdateVirtioScsiTarget(context.Context, *UpdateVirtioScsiTargetRequest) (*VirtioScsiTarget, error)
	// List Virtio Scsi Targets
	ListVirtioScsiTargets(context.Context, *ListVirtioScsiTargetsRequest) (*ListVirtioScsiTargetsResponse, error)
	// Get an Virtio Scsi Target
	GetVirtioScsiTarget(context.Context, *GetVirtioScsiTargetRequest) (*VirtioScsiTarget, error)
	// Get an Virtio Scsi Target statistics
	StatsVirtioScsiTarget(context.Context, *StatsVirtioScsiTargetRequest) (*StatsVirtioScsiTargetResponse, error)
	// Create an Virtio Scsi Controller
	CreateVirtioScsiController(context.Context, *CreateVirtioScsiControllerRequest) (*VirtioScsiController, error)
	// Delete an Virtio Scsi Controller
	DeleteVirtioScsiController(context.Context, *DeleteVirtioScsiControllerRequest) (*emptypb.Empty, error)
	// Update an Virtio Scsi Controller
	UpdateVirtioScsiController(context.Context, *UpdateVirtioScsiControllerRequest) (*VirtioScsiController, error)
	// List Virtio Scsi Controllers
	ListVirtioScsiControllers(context.Context, *ListVirtioScsiControllersRequest) (*ListVirtioScsiControllersResponse, error)
	// Get an Virtio Scsi Controller
	GetVirtioScsiController(context.Context, *GetVirtioScsiControllerRequest) (*VirtioScsiController, error)
	// Get an Virtio Scsi Controller statistics
	StatsVirtioScsiController(context.Context, *StatsVirtioScsiControllerRequest) (*StatsVirtioScsiControllerResponse, error)
	// Create an Virtio Scsi Lun
	CreateVirtioScsiLun(context.Context, *CreateVirtioScsiLunRequest) (*VirtioScsiLun, error)
	// Delete an Virtio Scsi Lun
	DeleteVirtioScsiLun(context.Context, *DeleteVirtioScsiLunRequest) (*emptypb.Empty, error)
	// Update an Virtio Scsi Lun
	UpdateVirtioScsiLun(context.Context, *UpdateVirtioScsiLunRequest) (*VirtioScsiLun, error)
	// List Virtio Scsi Luns
	ListVirtioScsiLuns(context.Context, *ListVirtioScsiLunsRequest) (*ListVirtioScsiLunsResponse, error)
	// Get an Virtio Scsi Lun
	GetVirtioScsiLun(context.Context, *GetVirtioScsiLunRequest) (*VirtioScsiLun, error)
	// Get an Virtio Scsi Lun statistics
	StatsVirtioScsiLun(context.Context, *StatsVirtioScsiLunRequest) (*StatsVirtioScsiLunResponse, error)
	// contains filtered or unexported methods
}

FrontendVirtioScsiServiceServer is the server API for FrontendVirtioScsiService service. All implementations must embed UnimplementedFrontendVirtioScsiServiceServer for forward compatibility

type GetAioVolumeRequest 

type GetAioVolumeRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Aio Volume.

func (*GetAioVolumeRequest) Descriptor deprecated 

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

Deprecated: Use GetAioVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetAioVolumeRequest) GetName 

func (x *GetAioVolumeRequest) GetName() string

func (*GetAioVolumeRequest) ProtoMessage 

func (*GetAioVolumeRequest) ProtoMessage()

func (*GetAioVolumeRequest) ProtoReflect 

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

func (*GetAioVolumeRequest) Reset 

func (x *GetAioVolumeRequest) Reset()

func (*GetAioVolumeRequest) String 

func (x *GetAioVolumeRequest) String() string

type GetEncryptedVolumeRequest 

type GetEncryptedVolumeRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Encrypted Volume.

func (*GetEncryptedVolumeRequest) Descriptor deprecated 

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

Deprecated: Use GetEncryptedVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetEncryptedVolumeRequest) GetName 

func (x *GetEncryptedVolumeRequest) GetName() string

func (*GetEncryptedVolumeRequest) ProtoMessage 

func (*GetEncryptedVolumeRequest) ProtoMessage()

func (*GetEncryptedVolumeRequest) ProtoReflect 

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

func (*GetEncryptedVolumeRequest) Reset 

func (x *GetEncryptedVolumeRequest) Reset()

func (*GetEncryptedVolumeRequest) String 

func (x *GetEncryptedVolumeRequest) String() string

type GetMallocVolumeRequest 

type GetMallocVolumeRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get a Malloc Volume.

func (*GetMallocVolumeRequest) Descriptor deprecated 

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

Deprecated: Use GetMallocVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetMallocVolumeRequest) GetName 

func (x *GetMallocVolumeRequest) GetName() string

func (*GetMallocVolumeRequest) ProtoMessage 

func (*GetMallocVolumeRequest) ProtoMessage()

func (*GetMallocVolumeRequest) ProtoReflect 

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

func (*GetMallocVolumeRequest) Reset 

func (x *GetMallocVolumeRequest) Reset()

func (*GetMallocVolumeRequest) String 

func (x *GetMallocVolumeRequest) String() string

type GetNullVolumeRequest 

type GetNullVolumeRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Null Volume.

func (*GetNullVolumeRequest) Descriptor deprecated 

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

Deprecated: Use GetNullVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetNullVolumeRequest) GetName 

func (x *GetNullVolumeRequest) GetName() string

func (*GetNullVolumeRequest) ProtoMessage 

func (*GetNullVolumeRequest) ProtoMessage()

func (*GetNullVolumeRequest) ProtoReflect 

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

func (*GetNullVolumeRequest) Reset 

func (x *GetNullVolumeRequest) Reset()

func (*GetNullVolumeRequest) String 

func (x *GetNullVolumeRequest) String() string

type GetNvmeControllerRequest 

type GetNvmeControllerRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Controller.

func (*GetNvmeControllerRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmeControllerRequest.ProtoReflect.Descriptor instead.

func (*GetNvmeControllerRequest) GetName 

func (x *GetNvmeControllerRequest) GetName() string

func (*GetNvmeControllerRequest) ProtoMessage 

func (*GetNvmeControllerRequest) ProtoMessage()

func (*GetNvmeControllerRequest) ProtoReflect 

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

func (*GetNvmeControllerRequest) Reset 

func (x *GetNvmeControllerRequest) Reset()

func (*GetNvmeControllerRequest) String 

func (x *GetNvmeControllerRequest) String() string

type GetNvmeNamespaceRequest 

type GetNvmeNamespaceRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Namespace.

func (*GetNvmeNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmeNamespaceRequest.ProtoReflect.Descriptor instead.

func (*GetNvmeNamespaceRequest) GetName 

func (x *GetNvmeNamespaceRequest) GetName() string

func (*GetNvmeNamespaceRequest) ProtoMessage 

func (*GetNvmeNamespaceRequest) ProtoMessage()

func (*GetNvmeNamespaceRequest) ProtoReflect 

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

func (*GetNvmeNamespaceRequest) Reset 

func (x *GetNvmeNamespaceRequest) Reset()

func (*GetNvmeNamespaceRequest) String 

func (x *GetNvmeNamespaceRequest) String() string

type GetNvmePathRequest 

type GetNvmePathRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Path.

func (*GetNvmePathRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmePathRequest.ProtoReflect.Descriptor instead.

func (*GetNvmePathRequest) GetName 

func (x *GetNvmePathRequest) GetName() string

func (*GetNvmePathRequest) ProtoMessage 

func (*GetNvmePathRequest) ProtoMessage()

func (*GetNvmePathRequest) ProtoReflect 

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

func (*GetNvmePathRequest) Reset 

func (x *GetNvmePathRequest) Reset()

func (*GetNvmePathRequest) String 

func (x *GetNvmePathRequest) String() string

type GetNvmeRemoteControllerRequest 

type GetNvmeRemoteControllerRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Remote Controller.

func (*GetNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*GetNvmeRemoteControllerRequest) GetName 

func (x *GetNvmeRemoteControllerRequest) GetName() string

func (*GetNvmeRemoteControllerRequest) ProtoMessage 

func (*GetNvmeRemoteControllerRequest) ProtoMessage()

func (*GetNvmeRemoteControllerRequest) ProtoReflect 

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

func (*GetNvmeRemoteControllerRequest) Reset 

func (x *GetNvmeRemoteControllerRequest) Reset()

func (*GetNvmeRemoteControllerRequest) String 

func (x *GetNvmeRemoteControllerRequest) String() string

type GetNvmeRemoteNamespaceRequest 

type GetNvmeRemoteNamespaceRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Remote Namespace.

func (*GetNvmeRemoteNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmeRemoteNamespaceRequest.ProtoReflect.Descriptor instead.

func (*GetNvmeRemoteNamespaceRequest) GetName 

func (x *GetNvmeRemoteNamespaceRequest) GetName() string

func (*GetNvmeRemoteNamespaceRequest) ProtoMessage 

func (*GetNvmeRemoteNamespaceRequest) ProtoMessage()

func (*GetNvmeRemoteNamespaceRequest) ProtoReflect 

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

func (*GetNvmeRemoteNamespaceRequest) Reset 

func (x *GetNvmeRemoteNamespaceRequest) Reset()

func (*GetNvmeRemoteNamespaceRequest) String 

func (x *GetNvmeRemoteNamespaceRequest) String() string

type GetNvmeSubsystemRequest 

type GetNvmeSubsystemRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Subsystem.

func (*GetNvmeSubsystemRequest) Descriptor deprecated 

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

Deprecated: Use GetNvmeSubsystemRequest.ProtoReflect.Descriptor instead.

func (*GetNvmeSubsystemRequest) GetName 

func (x *GetNvmeSubsystemRequest) GetName() string

func (*GetNvmeSubsystemRequest) ProtoMessage 

func (*GetNvmeSubsystemRequest) ProtoMessage()

func (*GetNvmeSubsystemRequest) ProtoReflect 

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

func (*GetNvmeSubsystemRequest) Reset 

func (x *GetNvmeSubsystemRequest) Reset()

func (*GetNvmeSubsystemRequest) String 

func (x *GetNvmeSubsystemRequest) String() string

type GetQosVolumeRequest 

type GetQosVolumeRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an QoS Volume.

func (*GetQosVolumeRequest) Descriptor deprecated 

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

Deprecated: Use GetQosVolumeRequest.ProtoReflect.Descriptor instead.

func (*GetQosVolumeRequest) GetName 

func (x *GetQosVolumeRequest) GetName() string

func (*GetQosVolumeRequest) ProtoMessage 

func (*GetQosVolumeRequest) ProtoMessage()

func (*GetQosVolumeRequest) ProtoReflect 

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

func (*GetQosVolumeRequest) Reset 

func (x *GetQosVolumeRequest) Reset()

func (*GetQosVolumeRequest) String 

func (x *GetQosVolumeRequest) String() string

type GetVirtioBlkRequest 

type GetVirtioBlkRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Blk.

func (*GetVirtioBlkRequest) Descriptor deprecated 

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

Deprecated: Use GetVirtioBlkRequest.ProtoReflect.Descriptor instead.

func (*GetVirtioBlkRequest) GetName 

func (x *GetVirtioBlkRequest) GetName() string

func (*GetVirtioBlkRequest) ProtoMessage 

func (*GetVirtioBlkRequest) ProtoMessage()

func (*GetVirtioBlkRequest) ProtoReflect 

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

func (*GetVirtioBlkRequest) Reset 

func (x *GetVirtioBlkRequest) Reset()

func (*GetVirtioBlkRequest) String 

func (x *GetVirtioBlkRequest) String() string

type GetVirtioScsiControllerRequest 

type GetVirtioScsiControllerRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Controller.

func (*GetVirtioScsiControllerRequest) Descriptor deprecated 

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

Deprecated: Use GetVirtioScsiControllerRequest.ProtoReflect.Descriptor instead.

func (*GetVirtioScsiControllerRequest) GetName 

func (x *GetVirtioScsiControllerRequest) GetName() string

func (*GetVirtioScsiControllerRequest) ProtoMessage 

func (*GetVirtioScsiControllerRequest) ProtoMessage()

func (*GetVirtioScsiControllerRequest) ProtoReflect 

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

func (*GetVirtioScsiControllerRequest) Reset 

func (x *GetVirtioScsiControllerRequest) Reset()

func (*GetVirtioScsiControllerRequest) String 

func (x *GetVirtioScsiControllerRequest) String() string

type GetVirtioScsiLunRequest 

type GetVirtioScsiLunRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Lun.

func (*GetVirtioScsiLunRequest) Descriptor deprecated 

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

Deprecated: Use GetVirtioScsiLunRequest.ProtoReflect.Descriptor instead.

func (*GetVirtioScsiLunRequest) GetName 

func (x *GetVirtioScsiLunRequest) GetName() string

func (*GetVirtioScsiLunRequest) ProtoMessage 

func (*GetVirtioScsiLunRequest) ProtoMessage()

func (*GetVirtioScsiLunRequest) ProtoReflect 

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

func (*GetVirtioScsiLunRequest) Reset 

func (x *GetVirtioScsiLunRequest) Reset()

func (*GetVirtioScsiLunRequest) String 

func (x *GetVirtioScsiLunRequest) String() string

type GetVirtioScsiTargetRequest 

type GetVirtioScsiTargetRequest struct {

	// Object's unique identifier to retrieve
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Target.

func (*GetVirtioScsiTargetRequest) Descriptor deprecated 

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

Deprecated: Use GetVirtioScsiTargetRequest.ProtoReflect.Descriptor instead.

func (*GetVirtioScsiTargetRequest) GetName 

func (x *GetVirtioScsiTargetRequest) GetName() string

func (*GetVirtioScsiTargetRequest) ProtoMessage 

func (*GetVirtioScsiTargetRequest) ProtoMessage()

func (*GetVirtioScsiTargetRequest) ProtoReflect 

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

func (*GetVirtioScsiTargetRequest) Reset 

func (x *GetVirtioScsiTargetRequest) Reset()

func (*GetVirtioScsiTargetRequest) String 

func (x *GetVirtioScsiTargetRequest) String() string

type Limits 

type Limits struct {

	// Min QoS limits for the volume
	Min *QosLimit `protobuf:"bytes,1,opt,name=min,proto3" json:"min,omitempty"`
	// Max QoS limits for the volume
	Max *QosLimit `protobuf:"bytes,2,opt,name=max,proto3" json:"max,omitempty"`
	// contains filtered or unexported fields
}

Represents limits for Qos Volume

func (*Limits) Descriptor deprecated 

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

Deprecated: Use Limits.ProtoReflect.Descriptor instead.

func (*Limits) GetMax 

func (x *Limits) GetMax() *QosLimit

func (*Limits) GetMin 

func (x *Limits) GetMin() *QosLimit

func (*Limits) ProtoMessage 

func (*Limits) ProtoMessage()

func (*Limits) ProtoReflect 

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

func (*Limits) Reset 

func (x *Limits) Reset()

func (*Limits) String 

func (x *Limits) String() string

type ListAioVolumesRequest 

type ListAioVolumesRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Aio Volumes.

func (*ListAioVolumesRequest) Descriptor deprecated 

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

Deprecated: Use ListAioVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListAioVolumesRequest) GetPageSize 

func (x *ListAioVolumesRequest) GetPageSize() int32

func (*ListAioVolumesRequest) GetPageToken 

func (x *ListAioVolumesRequest) GetPageToken() string

func (*ListAioVolumesRequest) ProtoMessage 

func (*ListAioVolumesRequest) ProtoMessage()

func (*ListAioVolumesRequest) ProtoReflect 

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

func (*ListAioVolumesRequest) Reset 

func (x *ListAioVolumesRequest) Reset()

func (*ListAioVolumesRequest) String 

func (x *ListAioVolumesRequest) String() string

type ListAioVolumesResponse 

type ListAioVolumesResponse struct {

	// List of Aio volumes
	AioVolumes []*AioVolume `protobuf:"bytes,1,rep,name=aio_volumes,json=aioVolumes,proto3" json:"aio_volumes,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Aio Volumes.

func (*ListAioVolumesResponse) Descriptor deprecated 

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

Deprecated: Use ListAioVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListAioVolumesResponse) GetAioVolumes 

func (x *ListAioVolumesResponse) GetAioVolumes() []*AioVolume

func (*ListAioVolumesResponse) GetNextPageToken 

func (x *ListAioVolumesResponse) GetNextPageToken() string

func (*ListAioVolumesResponse) ProtoMessage 

func (*ListAioVolumesResponse) ProtoMessage()

func (*ListAioVolumesResponse) ProtoReflect 

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

func (*ListAioVolumesResponse) Reset 

func (x *ListAioVolumesResponse) Reset()

func (*ListAioVolumesResponse) String 

func (x *ListAioVolumesResponse) String() string

type ListEncryptedVolumesRequest 

type ListEncryptedVolumesRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Encrypted Volumes.

func (*ListEncryptedVolumesRequest) Descriptor deprecated 

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

Deprecated: Use ListEncryptedVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListEncryptedVolumesRequest) GetPageSize 

func (x *ListEncryptedVolumesRequest) GetPageSize() int32

func (*ListEncryptedVolumesRequest) GetPageToken 

func (x *ListEncryptedVolumesRequest) GetPageToken() string

func (*ListEncryptedVolumesRequest) GetParent 

func (x *ListEncryptedVolumesRequest) GetParent() string

func (*ListEncryptedVolumesRequest) ProtoMessage 

func (*ListEncryptedVolumesRequest) ProtoMessage()

func (*ListEncryptedVolumesRequest) ProtoReflect 

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

func (*ListEncryptedVolumesRequest) Reset 

func (x *ListEncryptedVolumesRequest) Reset()

func (*ListEncryptedVolumesRequest) String 

func (x *ListEncryptedVolumesRequest) String() string

type ListEncryptedVolumesResponse 

type ListEncryptedVolumesResponse struct {

	// List of Encrypted Volumes
	EncryptedVolumes []*EncryptedVolume `protobuf:"bytes,1,rep,name=encrypted_volumes,json=encryptedVolumes,proto3" json:"encrypted_volumes,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Encrypted Volumes.

func (*ListEncryptedVolumesResponse) Descriptor deprecated 

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

Deprecated: Use ListEncryptedVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListEncryptedVolumesResponse) GetEncryptedVolumes 

func (x *ListEncryptedVolumesResponse) GetEncryptedVolumes() []*EncryptedVolume

func (*ListEncryptedVolumesResponse) GetNextPageToken 

func (x *ListEncryptedVolumesResponse) GetNextPageToken() string

func (*ListEncryptedVolumesResponse) ProtoMessage 

func (*ListEncryptedVolumesResponse) ProtoMessage()

func (*ListEncryptedVolumesResponse) ProtoReflect 

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

func (*ListEncryptedVolumesResponse) Reset 

func (x *ListEncryptedVolumesResponse) Reset()

func (*ListEncryptedVolumesResponse) String 

func (x *ListEncryptedVolumesResponse) String() string

type ListMallocVolumesRequest 

type ListMallocVolumesRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Malloc Volumes.

func (*ListMallocVolumesRequest) Descriptor deprecated 

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

Deprecated: Use ListMallocVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListMallocVolumesRequest) GetPageSize 

func (x *ListMallocVolumesRequest) GetPageSize() int32

func (*ListMallocVolumesRequest) GetPageToken 

func (x *ListMallocVolumesRequest) GetPageToken() string

func (*ListMallocVolumesRequest) ProtoMessage 

func (*ListMallocVolumesRequest) ProtoMessage()

func (*ListMallocVolumesRequest) ProtoReflect 

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

func (*ListMallocVolumesRequest) Reset 

func (x *ListMallocVolumesRequest) Reset()

func (*ListMallocVolumesRequest) String 

func (x *ListMallocVolumesRequest) String() string

type ListMallocVolumesResponse 

type ListMallocVolumesResponse struct {

	// List of Malloc volumes
	MallocVolumes []*MallocVolume `protobuf:"bytes,1,rep,name=malloc_volumes,json=mallocVolumes,proto3" json:"malloc_volumes,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Malloc Volumes.

func (*ListMallocVolumesResponse) Descriptor deprecated 

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

Deprecated: Use ListMallocVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListMallocVolumesResponse) GetMallocVolumes 

func (x *ListMallocVolumesResponse) GetMallocVolumes() []*MallocVolume

func (*ListMallocVolumesResponse) GetNextPageToken 

func (x *ListMallocVolumesResponse) GetNextPageToken() string

func (*ListMallocVolumesResponse) ProtoMessage 

func (*ListMallocVolumesResponse) ProtoMessage()

func (*ListMallocVolumesResponse) ProtoReflect 

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

func (*ListMallocVolumesResponse) Reset 

func (x *ListMallocVolumesResponse) Reset()

func (*ListMallocVolumesResponse) String 

func (x *ListMallocVolumesResponse) String() string

type ListNullVolumesRequest 

type ListNullVolumesRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Null Volumes.

func (*ListNullVolumesRequest) Descriptor deprecated 

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

Deprecated: Use ListNullVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListNullVolumesRequest) GetPageSize 

func (x *ListNullVolumesRequest) GetPageSize() int32

func (*ListNullVolumesRequest) GetPageToken 

func (x *ListNullVolumesRequest) GetPageToken() string

func (*ListNullVolumesRequest) ProtoMessage 

func (*ListNullVolumesRequest) ProtoMessage()

func (*ListNullVolumesRequest) ProtoReflect 

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

func (*ListNullVolumesRequest) Reset 

func (x *ListNullVolumesRequest) Reset()

func (*ListNullVolumesRequest) String 

func (x *ListNullVolumesRequest) String() string

type ListNullVolumesResponse 

type ListNullVolumesResponse struct {

	// List of Null volumes
	NullVolumes []*NullVolume `protobuf:"bytes,1,rep,name=null_volumes,json=nullVolumes,proto3" json:"null_volumes,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Null Volumes.

func (*ListNullVolumesResponse) Descriptor deprecated 

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

Deprecated: Use ListNullVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListNullVolumesResponse) GetNextPageToken 

func (x *ListNullVolumesResponse) GetNextPageToken() string

func (*ListNullVolumesResponse) GetNullVolumes 

func (x *ListNullVolumesResponse) GetNullVolumes() []*NullVolume

func (*ListNullVolumesResponse) ProtoMessage 

func (*ListNullVolumesResponse) ProtoMessage()

func (*ListNullVolumesResponse) ProtoReflect 

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

func (*ListNullVolumesResponse) Reset 

func (x *ListNullVolumesResponse) Reset()

func (*ListNullVolumesResponse) String 

func (x *ListNullVolumesResponse) String() string

type ListNvmeControllersRequest 

type ListNvmeControllersRequest struct {

	// Parent's subsystem unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Controllers.

func (*ListNvmeControllersRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmeControllersRequest.ProtoReflect.Descriptor instead.

func (*ListNvmeControllersRequest) GetPageSize 

func (x *ListNvmeControllersRequest) GetPageSize() int32

func (*ListNvmeControllersRequest) GetPageToken 

func (x *ListNvmeControllersRequest) GetPageToken() string

func (*ListNvmeControllersRequest) GetParent 

func (x *ListNvmeControllersRequest) GetParent() string

func (*ListNvmeControllersRequest) ProtoMessage 

func (*ListNvmeControllersRequest) ProtoMessage()

func (*ListNvmeControllersRequest) ProtoReflect 

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

func (*ListNvmeControllersRequest) Reset 

func (x *ListNvmeControllersRequest) Reset()

func (*ListNvmeControllersRequest) String 

func (x *ListNvmeControllersRequest) String() string

type ListNvmeControllersResponse 

type ListNvmeControllersResponse struct {

	// List of Nvme controllers
	NvmeControllers []*NvmeController `protobuf:"bytes,1,rep,name=nvme_controllers,json=nvmeControllers,proto3" json:"nvme_controllers,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Controllers.

func (*ListNvmeControllersResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmeControllersResponse.ProtoReflect.Descriptor instead.

func (*ListNvmeControllersResponse) GetNextPageToken 

func (x *ListNvmeControllersResponse) GetNextPageToken() string

func (*ListNvmeControllersResponse) GetNvmeControllers 

func (x *ListNvmeControllersResponse) GetNvmeControllers() []*NvmeController

func (*ListNvmeControllersResponse) ProtoMessage 

func (*ListNvmeControllersResponse) ProtoMessage()

func (*ListNvmeControllersResponse) ProtoReflect 

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

func (*ListNvmeControllersResponse) Reset 

func (x *ListNvmeControllersResponse) Reset()

func (*ListNvmeControllersResponse) String 

func (x *ListNvmeControllersResponse) String() string

type ListNvmeNamespacesRequest 

type ListNvmeNamespacesRequest struct {

	// Parent's subsystem unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Namespaces.

func (*ListNvmeNamespacesRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmeNamespacesRequest.ProtoReflect.Descriptor instead.

func (*ListNvmeNamespacesRequest) GetPageSize 

func (x *ListNvmeNamespacesRequest) GetPageSize() int32

func (*ListNvmeNamespacesRequest) GetPageToken 

func (x *ListNvmeNamespacesRequest) GetPageToken() string

func (*ListNvmeNamespacesRequest) GetParent 

func (x *ListNvmeNamespacesRequest) GetParent() string

func (*ListNvmeNamespacesRequest) ProtoMessage 

func (*ListNvmeNamespacesRequest) ProtoMessage()

func (*ListNvmeNamespacesRequest) ProtoReflect 

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

func (*ListNvmeNamespacesRequest) Reset 

func (x *ListNvmeNamespacesRequest) Reset()

func (*ListNvmeNamespacesRequest) String 

func (x *ListNvmeNamespacesRequest) String() string

type ListNvmeNamespacesResponse 

type ListNvmeNamespacesResponse struct {

	// List of Nvme Namespaces
	NvmeNamespaces []*NvmeNamespace `protobuf:"bytes,1,rep,name=nvme_namespaces,json=nvmeNamespaces,proto3" json:"nvme_namespaces,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Namespaces.

func (*ListNvmeNamespacesResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmeNamespacesResponse.ProtoReflect.Descriptor instead.

func (*ListNvmeNamespacesResponse) GetNextPageToken 

func (x *ListNvmeNamespacesResponse) GetNextPageToken() string

func (*ListNvmeNamespacesResponse) GetNvmeNamespaces 

func (x *ListNvmeNamespacesResponse) GetNvmeNamespaces() []*NvmeNamespace

func (*ListNvmeNamespacesResponse) ProtoMessage 

func (*ListNvmeNamespacesResponse) ProtoMessage()

func (*ListNvmeNamespacesResponse) ProtoReflect 

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

func (*ListNvmeNamespacesResponse) Reset 

func (x *ListNvmeNamespacesResponse) Reset()

func (*ListNvmeNamespacesResponse) String 

func (x *ListNvmeNamespacesResponse) String() string

type ListNvmePathsRequest 

type ListNvmePathsRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Paths.

func (*ListNvmePathsRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmePathsRequest.ProtoReflect.Descriptor instead.

func (*ListNvmePathsRequest) GetPageSize 

func (x *ListNvmePathsRequest) GetPageSize() int32

func (*ListNvmePathsRequest) GetPageToken 

func (x *ListNvmePathsRequest) GetPageToken() string

func (*ListNvmePathsRequest) GetParent 

func (x *ListNvmePathsRequest) GetParent() string

func (*ListNvmePathsRequest) ProtoMessage 

func (*ListNvmePathsRequest) ProtoMessage()

func (*ListNvmePathsRequest) ProtoReflect 

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

func (*ListNvmePathsRequest) Reset 

func (x *ListNvmePathsRequest) Reset()

func (*ListNvmePathsRequest) String 

func (x *ListNvmePathsRequest) String() string

type ListNvmePathsResponse 

type ListNvmePathsResponse struct {

	// List of Nvme Paths
	NvmePaths []*NvmePath `protobuf:"bytes,1,rep,name=nvme_paths,json=nvmePaths,proto3" json:"nvme_paths,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Paths.

func (*ListNvmePathsResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmePathsResponse.ProtoReflect.Descriptor instead.

func (*ListNvmePathsResponse) GetNextPageToken 

func (x *ListNvmePathsResponse) GetNextPageToken() string

func (*ListNvmePathsResponse) GetNvmePaths 

func (x *ListNvmePathsResponse) GetNvmePaths() []*NvmePath

func (*ListNvmePathsResponse) ProtoMessage 

func (*ListNvmePathsResponse) ProtoMessage()

func (*ListNvmePathsResponse) ProtoReflect 

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

func (*ListNvmePathsResponse) Reset 

func (x *ListNvmePathsResponse) Reset()

func (*ListNvmePathsResponse) String 

func (x *ListNvmePathsResponse) String() string

type ListNvmeRemoteControllersRequest 

type ListNvmeRemoteControllersRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Remote Controllers.

func (*ListNvmeRemoteControllersRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmeRemoteControllersRequest.ProtoReflect.Descriptor instead.

func (*ListNvmeRemoteControllersRequest) GetPageSize 

func (x *ListNvmeRemoteControllersRequest) GetPageSize() int32

func (*ListNvmeRemoteControllersRequest) GetPageToken 

func (x *ListNvmeRemoteControllersRequest) GetPageToken() string

func (*ListNvmeRemoteControllersRequest) ProtoMessage 

func (*ListNvmeRemoteControllersRequest) ProtoMessage()

func (*ListNvmeRemoteControllersRequest) ProtoReflect 

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

func (*ListNvmeRemoteControllersRequest) Reset 

func (x *ListNvmeRemoteControllersRequest) Reset()

func (*ListNvmeRemoteControllersRequest) String 

func (x *ListNvmeRemoteControllersRequest) String() string

type ListNvmeRemoteControllersResponse 

type ListNvmeRemoteControllersResponse struct {

	// List of Nvme Remote Controllers
	NvmeRemoteControllers []*NvmeRemoteController `` /* 126-byte string literal not displayed */
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Remote Controllers.

func (*ListNvmeRemoteControllersResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmeRemoteControllersResponse.ProtoReflect.Descriptor instead.

func (*ListNvmeRemoteControllersResponse) GetNextPageToken 

func (x *ListNvmeRemoteControllersResponse) GetNextPageToken() string

func (*ListNvmeRemoteControllersResponse) GetNvmeRemoteControllers 

func (x *ListNvmeRemoteControllersResponse) GetNvmeRemoteControllers() []*NvmeRemoteController

func (*ListNvmeRemoteControllersResponse) ProtoMessage 

func (*ListNvmeRemoteControllersResponse) ProtoMessage()

func (*ListNvmeRemoteControllersResponse) ProtoReflect 

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

func (*ListNvmeRemoteControllersResponse) Reset 

func (x *ListNvmeRemoteControllersResponse) Reset()

func (*ListNvmeRemoteControllersResponse) String 

func (x *ListNvmeRemoteControllersResponse) String() string

type ListNvmeRemoteNamespacesRequest 

type ListNvmeRemoteNamespacesRequest struct {

	// The controller's unique object identifier. This lists
	// namespaces for a particular controller.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Remote Namespaces.

func (*ListNvmeRemoteNamespacesRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmeRemoteNamespacesRequest.ProtoReflect.Descriptor instead.

func (*ListNvmeRemoteNamespacesRequest) GetPageSize 

func (x *ListNvmeRemoteNamespacesRequest) GetPageSize() int32

func (*ListNvmeRemoteNamespacesRequest) GetPageToken 

func (x *ListNvmeRemoteNamespacesRequest) GetPageToken() string

func (*ListNvmeRemoteNamespacesRequest) GetParent 

func (x *ListNvmeRemoteNamespacesRequest) GetParent() string

func (*ListNvmeRemoteNamespacesRequest) ProtoMessage 

func (*ListNvmeRemoteNamespacesRequest) ProtoMessage()

func (*ListNvmeRemoteNamespacesRequest) ProtoReflect 

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

func (*ListNvmeRemoteNamespacesRequest) Reset 

func (x *ListNvmeRemoteNamespacesRequest) Reset()

func (*ListNvmeRemoteNamespacesRequest) String 

func (x *ListNvmeRemoteNamespacesRequest) String() string

type ListNvmeRemoteNamespacesResponse 

type ListNvmeRemoteNamespacesResponse struct {

	// List of Remote Namespaces
	NvmeRemoteNamespaces []*NvmeRemoteNamespace `protobuf:"bytes,1,rep,name=nvme_remote_namespaces,json=nvmeRemoteNamespaces,proto3" json:"nvme_remote_namespaces,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Remote Namespaces.

func (*ListNvmeRemoteNamespacesResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmeRemoteNamespacesResponse.ProtoReflect.Descriptor instead.

func (*ListNvmeRemoteNamespacesResponse) GetNextPageToken 

func (x *ListNvmeRemoteNamespacesResponse) GetNextPageToken() string

func (*ListNvmeRemoteNamespacesResponse) GetNvmeRemoteNamespaces 

func (x *ListNvmeRemoteNamespacesResponse) GetNvmeRemoteNamespaces() []*NvmeRemoteNamespace

func (*ListNvmeRemoteNamespacesResponse) ProtoMessage 

func (*ListNvmeRemoteNamespacesResponse) ProtoMessage()

func (*ListNvmeRemoteNamespacesResponse) ProtoReflect 

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

func (*ListNvmeRemoteNamespacesResponse) Reset 

func (x *ListNvmeRemoteNamespacesResponse) Reset()

func (*ListNvmeRemoteNamespacesResponse) String 

func (x *ListNvmeRemoteNamespacesResponse) String() string

type ListNvmeSubsystemsRequest 

type ListNvmeSubsystemsRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Nvme Subsystems.

func (*ListNvmeSubsystemsRequest) Descriptor deprecated 

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

Deprecated: Use ListNvmeSubsystemsRequest.ProtoReflect.Descriptor instead.

func (*ListNvmeSubsystemsRequest) GetPageSize 

func (x *ListNvmeSubsystemsRequest) GetPageSize() int32

func (*ListNvmeSubsystemsRequest) GetPageToken 

func (x *ListNvmeSubsystemsRequest) GetPageToken() string

func (*ListNvmeSubsystemsRequest) ProtoMessage 

func (*ListNvmeSubsystemsRequest) ProtoMessage()

func (*ListNvmeSubsystemsRequest) ProtoReflect 

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

func (*ListNvmeSubsystemsRequest) Reset 

func (x *ListNvmeSubsystemsRequest) Reset()

func (*ListNvmeSubsystemsRequest) String 

func (x *ListNvmeSubsystemsRequest) String() string

type ListNvmeSubsystemsResponse 

type ListNvmeSubsystemsResponse struct {

	// List of Nvme Subsystems
	NvmeSubsystems []*NvmeSubsystem `protobuf:"bytes,1,rep,name=nvme_subsystems,json=nvmeSubsystems,proto3" json:"nvme_subsystems,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Nvme Subsystems.

func (*ListNvmeSubsystemsResponse) Descriptor deprecated 

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

Deprecated: Use ListNvmeSubsystemsResponse.ProtoReflect.Descriptor instead.

func (*ListNvmeSubsystemsResponse) GetNextPageToken 

func (x *ListNvmeSubsystemsResponse) GetNextPageToken() string

func (*ListNvmeSubsystemsResponse) GetNvmeSubsystems 

func (x *ListNvmeSubsystemsResponse) GetNvmeSubsystems() []*NvmeSubsystem

func (*ListNvmeSubsystemsResponse) ProtoMessage 

func (*ListNvmeSubsystemsResponse) ProtoMessage()

func (*ListNvmeSubsystemsResponse) ProtoReflect 

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

func (*ListNvmeSubsystemsResponse) Reset 

func (x *ListNvmeSubsystemsResponse) Reset()

func (*ListNvmeSubsystemsResponse) String 

func (x *ListNvmeSubsystemsResponse) String() string

type ListQosVolumesRequest 

type ListQosVolumesRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all QoS Volumes.

func (*ListQosVolumesRequest) Descriptor deprecated 

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

Deprecated: Use ListQosVolumesRequest.ProtoReflect.Descriptor instead.

func (*ListQosVolumesRequest) GetPageSize 

func (x *ListQosVolumesRequest) GetPageSize() int32

func (*ListQosVolumesRequest) GetPageToken 

func (x *ListQosVolumesRequest) GetPageToken() string

func (*ListQosVolumesRequest) GetParent 

func (x *ListQosVolumesRequest) GetParent() string

func (*ListQosVolumesRequest) ProtoMessage 

func (*ListQosVolumesRequest) ProtoMessage()

func (*ListQosVolumesRequest) ProtoReflect 

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

func (*ListQosVolumesRequest) Reset 

func (x *ListQosVolumesRequest) Reset()

func (*ListQosVolumesRequest) String 

func (x *ListQosVolumesRequest) String() string

type ListQosVolumesResponse 

type ListQosVolumesResponse struct {

	// List of Qos Volumes
	QosVolumes []*QosVolume `protobuf:"bytes,1,rep,name=qos_volumes,json=qosVolumes,proto3" json:"qos_volumes,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all QoS Volumes.

func (*ListQosVolumesResponse) Descriptor deprecated 

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

Deprecated: Use ListQosVolumesResponse.ProtoReflect.Descriptor instead.

func (*ListQosVolumesResponse) GetNextPageToken 

func (x *ListQosVolumesResponse) GetNextPageToken() string

func (*ListQosVolumesResponse) GetQosVolumes 

func (x *ListQosVolumesResponse) GetQosVolumes() []*QosVolume

func (*ListQosVolumesResponse) ProtoMessage 

func (*ListQosVolumesResponse) ProtoMessage()

func (*ListQosVolumesResponse) ProtoReflect 

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

func (*ListQosVolumesResponse) Reset 

func (x *ListQosVolumesResponse) Reset()

func (*ListQosVolumesResponse) String 

func (x *ListQosVolumesResponse) String() string

type ListVirtioBlksRequest 

type ListVirtioBlksRequest struct {

	// page size of list request
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Virtio Blks.

func (*ListVirtioBlksRequest) Descriptor deprecated 

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

Deprecated: Use ListVirtioBlksRequest.ProtoReflect.Descriptor instead.

func (*ListVirtioBlksRequest) GetPageSize 

func (x *ListVirtioBlksRequest) GetPageSize() int32

func (*ListVirtioBlksRequest) GetPageToken 

func (x *ListVirtioBlksRequest) GetPageToken() string

func (*ListVirtioBlksRequest) ProtoMessage 

func (*ListVirtioBlksRequest) ProtoMessage()

func (*ListVirtioBlksRequest) ProtoReflect 

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

func (*ListVirtioBlksRequest) Reset 

func (x *ListVirtioBlksRequest) Reset()

func (*ListVirtioBlksRequest) String 

func (x *ListVirtioBlksRequest) String() string

type ListVirtioBlksResponse 

type ListVirtioBlksResponse struct {

	// List of Virtio-Blk devices
	VirtioBlks []*VirtioBlk `protobuf:"bytes,1,rep,name=virtio_blks,json=virtioBlks,proto3" json:"virtio_blks,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Virtio Blks.

func (*ListVirtioBlksResponse) Descriptor deprecated 

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

Deprecated: Use ListVirtioBlksResponse.ProtoReflect.Descriptor instead.

func (*ListVirtioBlksResponse) GetNextPageToken 

func (x *ListVirtioBlksResponse) GetNextPageToken() string

func (*ListVirtioBlksResponse) GetVirtioBlks 

func (x *ListVirtioBlksResponse) GetVirtioBlks() []*VirtioBlk

func (*ListVirtioBlksResponse) ProtoMessage 

func (*ListVirtioBlksResponse) ProtoMessage()

func (*ListVirtioBlksResponse) ProtoReflect 

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

func (*ListVirtioBlksResponse) Reset 

func (x *ListVirtioBlksResponse) Reset()

func (*ListVirtioBlksResponse) String 

func (x *ListVirtioBlksResponse) String() string

type ListVirtioScsiControllersRequest 

type ListVirtioScsiControllersRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Virtio Scsi Controllers.

func (*ListVirtioScsiControllersRequest) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiControllersRequest.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiControllersRequest) GetPageSize 

func (x *ListVirtioScsiControllersRequest) GetPageSize() int32

func (*ListVirtioScsiControllersRequest) GetPageToken 

func (x *ListVirtioScsiControllersRequest) GetPageToken() string

func (*ListVirtioScsiControllersRequest) GetParent 

func (x *ListVirtioScsiControllersRequest) GetParent() string

func (*ListVirtioScsiControllersRequest) ProtoMessage 

func (*ListVirtioScsiControllersRequest) ProtoMessage()

func (*ListVirtioScsiControllersRequest) ProtoReflect 

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

func (*ListVirtioScsiControllersRequest) Reset 

func (x *ListVirtioScsiControllersRequest) Reset()

func (*ListVirtioScsiControllersRequest) String 

func (x *ListVirtioScsiControllersRequest) String() string

type ListVirtioScsiControllersResponse 

type ListVirtioScsiControllersResponse struct {

	// List of Scsi Controllers
	VirtioScsiControllers []*VirtioScsiController `` /* 126-byte string literal not displayed */
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Virtio Scsi Controllers.

func (*ListVirtioScsiControllersResponse) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiControllersResponse.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiControllersResponse) GetNextPageToken 

func (x *ListVirtioScsiControllersResponse) GetNextPageToken() string

func (*ListVirtioScsiControllersResponse) GetVirtioScsiControllers 

func (x *ListVirtioScsiControllersResponse) GetVirtioScsiControllers() []*VirtioScsiController

func (*ListVirtioScsiControllersResponse) ProtoMessage 

func (*ListVirtioScsiControllersResponse) ProtoMessage()

func (*ListVirtioScsiControllersResponse) ProtoReflect 

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

func (*ListVirtioScsiControllersResponse) Reset 

func (x *ListVirtioScsiControllersResponse) Reset()

func (*ListVirtioScsiControllersResponse) String 

func (x *ListVirtioScsiControllersResponse) String() string

type ListVirtioScsiLunsRequest 

type ListVirtioScsiLunsRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Virtio Scsi Luns.

func (*ListVirtioScsiLunsRequest) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiLunsRequest.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiLunsRequest) GetPageSize 

func (x *ListVirtioScsiLunsRequest) GetPageSize() int32

func (*ListVirtioScsiLunsRequest) GetPageToken 

func (x *ListVirtioScsiLunsRequest) GetPageToken() string

func (*ListVirtioScsiLunsRequest) GetParent 

func (x *ListVirtioScsiLunsRequest) GetParent() string

func (*ListVirtioScsiLunsRequest) ProtoMessage 

func (*ListVirtioScsiLunsRequest) ProtoMessage()

func (*ListVirtioScsiLunsRequest) ProtoReflect 

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

func (*ListVirtioScsiLunsRequest) Reset 

func (x *ListVirtioScsiLunsRequest) Reset()

func (*ListVirtioScsiLunsRequest) String 

func (x *ListVirtioScsiLunsRequest) String() string

type ListVirtioScsiLunsResponse 

type ListVirtioScsiLunsResponse struct {

	// List of Scsi Luns
	VirtioScsiLuns []*VirtioScsiLun `protobuf:"bytes,1,rep,name=virtio_scsi_luns,json=virtioScsiLuns,proto3" json:"virtio_scsi_luns,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Virtio Scsi Luns.

func (*ListVirtioScsiLunsResponse) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiLunsResponse.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiLunsResponse) GetNextPageToken 

func (x *ListVirtioScsiLunsResponse) GetNextPageToken() string

func (*ListVirtioScsiLunsResponse) GetVirtioScsiLuns 

func (x *ListVirtioScsiLunsResponse) GetVirtioScsiLuns() []*VirtioScsiLun

func (*ListVirtioScsiLunsResponse) ProtoMessage 

func (*ListVirtioScsiLunsResponse) ProtoMessage()

func (*ListVirtioScsiLunsResponse) ProtoReflect 

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

func (*ListVirtioScsiLunsResponse) Reset 

func (x *ListVirtioScsiLunsResponse) Reset()

func (*ListVirtioScsiLunsResponse) String 

func (x *ListVirtioScsiLunsResponse) String() string

type ListVirtioScsiTargetsRequest 

type ListVirtioScsiTargetsRequest struct {

	// Parent's object unique identifier
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// page size of list request
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// page token of list request
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to list all Virtio Scsi Targets.

func (*ListVirtioScsiTargetsRequest) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiTargetsRequest.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiTargetsRequest) GetPageSize 

func (x *ListVirtioScsiTargetsRequest) GetPageSize() int32

func (*ListVirtioScsiTargetsRequest) GetPageToken 

func (x *ListVirtioScsiTargetsRequest) GetPageToken() string

func (*ListVirtioScsiTargetsRequest) GetParent 

func (x *ListVirtioScsiTargetsRequest) GetParent() string

func (*ListVirtioScsiTargetsRequest) ProtoMessage 

func (*ListVirtioScsiTargetsRequest) ProtoMessage()

func (*ListVirtioScsiTargetsRequest) ProtoReflect 

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

func (*ListVirtioScsiTargetsRequest) Reset 

func (x *ListVirtioScsiTargetsRequest) Reset()

func (*ListVirtioScsiTargetsRequest) String 

func (x *ListVirtioScsiTargetsRequest) String() string

type ListVirtioScsiTargetsResponse 

type ListVirtioScsiTargetsResponse struct {

	// List of Scsi Targets
	VirtioScsiTargets []*VirtioScsiTarget `protobuf:"bytes,1,rep,name=virtio_scsi_targets,json=virtioScsiTargets,proto3" json:"virtio_scsi_targets,omitempty"`
	// Next page token of list response
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to list all Virtio Scsi Targets.

func (*ListVirtioScsiTargetsResponse) Descriptor deprecated 

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

Deprecated: Use ListVirtioScsiTargetsResponse.ProtoReflect.Descriptor instead.

func (*ListVirtioScsiTargetsResponse) GetNextPageToken 

func (x *ListVirtioScsiTargetsResponse) GetNextPageToken() string

func (*ListVirtioScsiTargetsResponse) GetVirtioScsiTargets 

func (x *ListVirtioScsiTargetsResponse) GetVirtioScsiTargets() []*VirtioScsiTarget

func (*ListVirtioScsiTargetsResponse) ProtoMessage 

func (*ListVirtioScsiTargetsResponse) ProtoMessage()

func (*ListVirtioScsiTargetsResponse) ProtoReflect 

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

func (*ListVirtioScsiTargetsResponse) Reset 

func (x *ListVirtioScsiTargetsResponse) Reset()

func (*ListVirtioScsiTargetsResponse) String 

func (x *ListVirtioScsiTargetsResponse) String() string

type MallocVolume 

type MallocVolume struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The block size of the MallocVolume.
	BlockSize int64 `protobuf:"varint,2,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
	// The number of blocks in the MallocVolume.
	BlocksCount int64 `protobuf:"varint,3,opt,name=blocks_count,json=blocksCount,proto3" json:"blocks_count,omitempty"`
	// The metadata size of the MallocVolume.
	MetadataSize int64 `protobuf:"varint,4,opt,name=metadata_size,json=metadataSize,proto3" json:"metadata_size,omitempty"`
	// The UUID of the MallocVolume.
	Uuid string `protobuf:"bytes,5,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// contains filtered or unexported fields
}

Malloc volume, volatile volume

func (*MallocVolume) Descriptor deprecated 

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

Deprecated: Use MallocVolume.ProtoReflect.Descriptor instead.

func (*MallocVolume) GetBlockSize 

func (x *MallocVolume) GetBlockSize() int64

func (*MallocVolume) GetBlocksCount 

func (x *MallocVolume) GetBlocksCount() int64

func (*MallocVolume) GetMetadataSize 

func (x *MallocVolume) GetMetadataSize() int64

func (*MallocVolume) GetName 

func (x *MallocVolume) GetName() string

func (*MallocVolume) GetUuid 

func (x *MallocVolume) GetUuid() string

func (*MallocVolume) ProtoMessage 

func (*MallocVolume) ProtoMessage()

func (*MallocVolume) ProtoReflect 

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

func (*MallocVolume) Reset 

func (x *MallocVolume) Reset()

func (*MallocVolume) String 

func (x *MallocVolume) String() string

type MallocVolumeServiceClient 

type MallocVolumeServiceClient interface {
	// Create a Malloc Volume
	CreateMallocVolume(ctx context.Context, in *CreateMallocVolumeRequest, opts ...grpc.CallOption) (*MallocVolume, error)
	// Delete a Malloc Volume
	DeleteMallocVolume(ctx context.Context, in *DeleteMallocVolumeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update a Malloc Volume
	UpdateMallocVolume(ctx context.Context, in *UpdateMallocVolumeRequest, opts ...grpc.CallOption) (*MallocVolume, error)
	// List Malloc Volumes
	ListMallocVolumes(ctx context.Context, in *ListMallocVolumesRequest, opts ...grpc.CallOption) (*ListMallocVolumesResponse, error)
	// Get a Malloc Volume
	GetMallocVolume(ctx context.Context, in *GetMallocVolumeRequest, opts ...grpc.CallOption) (*MallocVolume, error)
	// Get a Malloc Volume statistics
	StatsMallocVolume(ctx context.Context, in *StatsMallocVolumeRequest, opts ...grpc.CallOption) (*StatsMallocVolumeResponse, error)
}

MallocVolumeServiceClient is the client API for MallocVolumeService 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 NewMallocVolumeServiceClient 

func NewMallocVolumeServiceClient(cc grpc.ClientConnInterface) MallocVolumeServiceClient

type MallocVolumeServiceServer 

type MallocVolumeServiceServer interface {
	// Create a Malloc Volume
	CreateMallocVolume(context.Context, *CreateMallocVolumeRequest) (*MallocVolume, error)
	// Delete a Malloc Volume
	DeleteMallocVolume(context.Context, *DeleteMallocVolumeRequest) (*emptypb.Empty, error)
	// Update a Malloc Volume
	UpdateMallocVolume(context.Context, *UpdateMallocVolumeRequest) (*MallocVolume, error)
	// List Malloc Volumes
	ListMallocVolumes(context.Context, *ListMallocVolumesRequest) (*ListMallocVolumesResponse, error)
	// Get a Malloc Volume
	GetMallocVolume(context.Context, *GetMallocVolumeRequest) (*MallocVolume, error)
	// Get a Malloc Volume statistics
	StatsMallocVolume(context.Context, *StatsMallocVolumeRequest) (*StatsMallocVolumeResponse, error)
	// contains filtered or unexported methods
}

MallocVolumeServiceServer is the server API for MallocVolumeService service. All implementations must embed UnimplementedMallocVolumeServiceServer for forward compatibility

type MiddleendEncryptionServiceClient 

type MiddleendEncryptionServiceClient interface {
	// Create an Encrypted Volume
	CreateEncryptedVolume(ctx context.Context, in *CreateEncryptedVolumeRequest, opts ...grpc.CallOption) (*EncryptedVolume, error)
	// Delete an Encrypted Volume
	DeleteEncryptedVolume(ctx context.Context, in *DeleteEncryptedVolumeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Encrypted Volume
	UpdateEncryptedVolume(ctx context.Context, in *UpdateEncryptedVolumeRequest, opts ...grpc.CallOption) (*EncryptedVolume, error)
	// List Encrypted Volumes
	ListEncryptedVolumes(ctx context.Context, in *ListEncryptedVolumesRequest, opts ...grpc.CallOption) (*ListEncryptedVolumesResponse, error)
	// Get an Encrypted Volume
	GetEncryptedVolume(ctx context.Context, in *GetEncryptedVolumeRequest, opts ...grpc.CallOption) (*EncryptedVolume, error)
	// Get an Encrypted Volume statistics
	StatsEncryptedVolume(ctx context.Context, in *StatsEncryptedVolumeRequest, opts ...grpc.CallOption) (*StatsEncryptedVolumeResponse, error)
}

MiddleendEncryptionServiceClient is the client API for MiddleendEncryptionService 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 NewMiddleendEncryptionServiceClient 

func NewMiddleendEncryptionServiceClient(cc grpc.ClientConnInterface) MiddleendEncryptionServiceClient

type MiddleendEncryptionServiceServer 

type MiddleendEncryptionServiceServer interface {
	// Create an Encrypted Volume
	CreateEncryptedVolume(context.Context, *CreateEncryptedVolumeRequest) (*EncryptedVolume, error)
	// Delete an Encrypted Volume
	DeleteEncryptedVolume(context.Context, *DeleteEncryptedVolumeRequest) (*emptypb.Empty, error)
	// Update an Encrypted Volume
	UpdateEncryptedVolume(context.Context, *UpdateEncryptedVolumeRequest) (*EncryptedVolume, error)
	// List Encrypted Volumes
	ListEncryptedVolumes(context.Context, *ListEncryptedVolumesRequest) (*ListEncryptedVolumesResponse, error)
	// Get an Encrypted Volume
	GetEncryptedVolume(context.Context, *GetEncryptedVolumeRequest) (*EncryptedVolume, error)
	// Get an Encrypted Volume statistics
	StatsEncryptedVolume(context.Context, *StatsEncryptedVolumeRequest) (*StatsEncryptedVolumeResponse, error)
	// contains filtered or unexported methods
}

MiddleendEncryptionServiceServer is the server API for MiddleendEncryptionService service. All implementations must embed UnimplementedMiddleendEncryptionServiceServer for forward compatibility

type MiddleendQosVolumeServiceClient 

type MiddleendQosVolumeServiceClient interface {
	// Create an Qos Volume
	CreateQosVolume(ctx context.Context, in *CreateQosVolumeRequest, opts ...grpc.CallOption) (*QosVolume, error)
	// Delete an Qos Volume
	DeleteQosVolume(ctx context.Context, in *DeleteQosVolumeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Qos Volume
	UpdateQosVolume(ctx context.Context, in *UpdateQosVolumeRequest, opts ...grpc.CallOption) (*QosVolume, error)
	// List Qos Volumes
	ListQosVolumes(ctx context.Context, in *ListQosVolumesRequest, opts ...grpc.CallOption) (*ListQosVolumesResponse, error)
	// Get an Qos Volume
	GetQosVolume(ctx context.Context, in *GetQosVolumeRequest, opts ...grpc.CallOption) (*QosVolume, error)
	// Get an Qos Volume statistics
	StatsQosVolume(ctx context.Context, in *StatsQosVolumeRequest, opts ...grpc.CallOption) (*StatsQosVolumeResponse, error)
}

MiddleendQosVolumeServiceClient is the client API for MiddleendQosVolumeService 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 NewMiddleendQosVolumeServiceClient 

func NewMiddleendQosVolumeServiceClient(cc grpc.ClientConnInterface) MiddleendQosVolumeServiceClient

type MiddleendQosVolumeServiceServer 

type MiddleendQosVolumeServiceServer interface {
	// Create an Qos Volume
	CreateQosVolume(context.Context, *CreateQosVolumeRequest) (*QosVolume, error)
	// Delete an Qos Volume
	DeleteQosVolume(context.Context, *DeleteQosVolumeRequest) (*emptypb.Empty, error)
	// Update an Qos Volume
	UpdateQosVolume(context.Context, *UpdateQosVolumeRequest) (*QosVolume, error)
	// List Qos Volumes
	ListQosVolumes(context.Context, *ListQosVolumesRequest) (*ListQosVolumesResponse, error)
	// Get an Qos Volume
	GetQosVolume(context.Context, *GetQosVolumeRequest) (*QosVolume, error)
	// Get an Qos Volume statistics
	StatsQosVolume(context.Context, *StatsQosVolumeRequest) (*StatsQosVolumeResponse, error)
	// contains filtered or unexported methods
}

MiddleendQosVolumeServiceServer is the server API for MiddleendQosVolumeService service. All implementations must embed UnimplementedMiddleendQosVolumeServiceServer for forward compatibility

type NullVolume 

type NullVolume struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The block size of the NullVolume. This field is required.
	BlockSize int64 `protobuf:"varint,2,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
	// The number of blocks in the NullVolume. This field is required.
	BlocksCount int64 `protobuf:"varint,3,opt,name=blocks_count,json=blocksCount,proto3" json:"blocks_count,omitempty"`
	// The UUID of the NullVolume. This field is optional.
	Uuid string `protobuf:"bytes,4,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// contains filtered or unexported fields
}

Null volume which discards writes and returns random reads

func (*NullVolume) Descriptor deprecated 

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

Deprecated: Use NullVolume.ProtoReflect.Descriptor instead.

func (*NullVolume) GetBlockSize 

func (x *NullVolume) GetBlockSize() int64

func (*NullVolume) GetBlocksCount 

func (x *NullVolume) GetBlocksCount() int64

func (*NullVolume) GetName 

func (x *NullVolume) GetName() string

func (*NullVolume) GetUuid 

func (x *NullVolume) GetUuid() string

func (*NullVolume) ProtoMessage 

func (*NullVolume) ProtoMessage()

func (*NullVolume) ProtoReflect 

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

func (*NullVolume) Reset 

func (x *NullVolume) Reset()

func (*NullVolume) String 

func (x *NullVolume) String() string

type NullVolumeServiceClient 

type NullVolumeServiceClient interface {
	// Create an Null Volume
	CreateNullVolume(ctx context.Context, in *CreateNullVolumeRequest, opts ...grpc.CallOption) (*NullVolume, error)
	// Delete an Null Volume
	DeleteNullVolume(ctx context.Context, in *DeleteNullVolumeRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Null Volume
	UpdateNullVolume(ctx context.Context, in *UpdateNullVolumeRequest, opts ...grpc.CallOption) (*NullVolume, error)
	// List Null Volumes
	ListNullVolumes(ctx context.Context, in *ListNullVolumesRequest, opts ...grpc.CallOption) (*ListNullVolumesResponse, error)
	// Get an Null Volume
	GetNullVolume(ctx context.Context, in *GetNullVolumeRequest, opts ...grpc.CallOption) (*NullVolume, error)
	// Get an Null Volume statistics
	StatsNullVolume(ctx context.Context, in *StatsNullVolumeRequest, opts ...grpc.CallOption) (*StatsNullVolumeResponse, error)
}

NullVolumeServiceClient is the client API for NullVolumeService 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 NewNullVolumeServiceClient 

func NewNullVolumeServiceClient(cc grpc.ClientConnInterface) NullVolumeServiceClient

type NullVolumeServiceServer 

type NullVolumeServiceServer interface {
	// Create an Null Volume
	CreateNullVolume(context.Context, *CreateNullVolumeRequest) (*NullVolume, error)
	// Delete an Null Volume
	DeleteNullVolume(context.Context, *DeleteNullVolumeRequest) (*emptypb.Empty, error)
	// Update an Null Volume
	UpdateNullVolume(context.Context, *UpdateNullVolumeRequest) (*NullVolume, error)
	// List Null Volumes
	ListNullVolumes(context.Context, *ListNullVolumesRequest) (*ListNullVolumesResponse, error)
	// Get an Null Volume
	GetNullVolume(context.Context, *GetNullVolumeRequest) (*NullVolume, error)
	// Get an Null Volume statistics
	StatsNullVolume(context.Context, *StatsNullVolumeRequest) (*StatsNullVolumeResponse, error)
	// contains filtered or unexported methods
}

NullVolumeServiceServer is the server API for NullVolumeService service. All implementations must embed UnimplementedNullVolumeServiceServer for forward compatibility

type NvmeAddressFamily 

type NvmeAddressFamily int32

Address family value options 

const (
	// Address family is not specified
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_UNSPECIFIED NvmeAddressFamily = 0
	// IPv4 address family
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_IPV4 NvmeAddressFamily = 1
	// IPv6 address family
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_IPV6 NvmeAddressFamily = 2
	// InfiniBand address family
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_IB NvmeAddressFamily = 3
	// Fibre channel address family
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_FC NvmeAddressFamily = 4
	// Intra host address family
	NvmeAddressFamily_NVME_ADDRESS_FAMILY_INTRA_HOST NvmeAddressFamily = 5
)

func (NvmeAddressFamily) Descriptor 

func (NvmeAddressFamily) Descriptor() protoreflect.EnumDescriptor

func (NvmeAddressFamily) Enum 

func (x NvmeAddressFamily) Enum() *NvmeAddressFamily

func (NvmeAddressFamily) EnumDescriptor deprecated 

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

Deprecated: Use NvmeAddressFamily.Descriptor instead.

func (NvmeAddressFamily) Number 

func (x NvmeAddressFamily) Number() protoreflect.EnumNumber

func (NvmeAddressFamily) String 

func (x NvmeAddressFamily) String() string

func (NvmeAddressFamily) Type 

func (NvmeAddressFamily) Type() protoreflect.EnumType

type NvmeController 

type NvmeController struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// spec holds configurable values
	Spec *NvmeControllerSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	// status holds server generated values
	Status *NvmeControllerStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Controller

func (*NvmeController) Descriptor deprecated 

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

Deprecated: Use NvmeController.ProtoReflect.Descriptor instead.

func (*NvmeController) GetName 

func (x *NvmeController) GetName() string

func (*NvmeController) GetSpec 

func (x *NvmeController) GetSpec() *NvmeControllerSpec

func (*NvmeController) GetStatus 

func (x *NvmeController) GetStatus() *NvmeControllerStatus

func (*NvmeController) ProtoMessage 

func (*NvmeController) ProtoMessage()

func (*NvmeController) ProtoReflect 

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

func (*NvmeController) Reset 

func (x *NvmeController) Reset()

func (*NvmeController) String 

func (x *NvmeController) String() string

type NvmeControllerSpec 

type NvmeControllerSpec struct {

	// subsystem controller id range: 0 to 65535.
	// must not be reused under the same subsystem
	NvmeControllerId *int32 `protobuf:"varint,1,opt,name=nvme_controller_id,json=nvmeControllerId,proto3,oneof" json:"nvme_controller_id,omitempty"`
	// transport type
	Trtype NvmeTransportType `protobuf:"varint,2,opt,name=trtype,proto3,enum=opi_api.storage.v1.NvmeTransportType" json:"trtype,omitempty"`
	// xPU's PCI/Fabrics endpoint for the controller.
	// One of the values is required
	// see https://github.com/aip-dev/google.aip.dev/issues/1147 for field_behavior annotations
	//
	// Types that are assignable to Endpoint:
	//
	//	*NvmeControllerSpec_PcieId
	//	*NvmeControllerSpec_FabricsId
	Endpoint isNvmeControllerSpec_Endpoint `protobuf_oneof:"endpoint"`
	// maximum number of host submission queues allowed.
	// If not set, the xPU will provide a default.
	MaxNsq int32 `protobuf:"varint,5,opt,name=max_nsq,json=maxNsq,proto3" json:"max_nsq,omitempty"`
	// maximum number of host completion queues allowed.
	// If not set, the xPU will provide a default.
	MaxNcq int32 `protobuf:"varint,6,opt,name=max_ncq,json=maxNcq,proto3" json:"max_ncq,omitempty"`
	// maximum number of submission queue entries per submission queue, as a power of 2.
	// default value as per spec is 6
	Sqes int32 `protobuf:"varint,7,opt,name=sqes,proto3" json:"sqes,omitempty"`
	// maximum number of completion queue entries per completion queue, as a power of 2.
	// default value as per spec is 4
	Cqes int32 `protobuf:"varint,8,opt,name=cqes,proto3" json:"cqes,omitempty"`
	// maximum Number of namespaces that will be provisioned under
	// the controller.
	MaxNamespaces int32 `protobuf:"varint,9,opt,name=max_namespaces,json=maxNamespaces,proto3" json:"max_namespaces,omitempty"`
	// min QoS limits for the controller
	MinLimit *QosLimit `protobuf:"bytes,10,opt,name=min_limit,json=minLimit,proto3" json:"min_limit,omitempty"`
	// max QoS limits for the controller
	MaxLimit *QosLimit `protobuf:"bytes,11,opt,name=max_limit,json=maxLimit,proto3" json:"max_limit,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Controller configuration

func (*NvmeControllerSpec) Descriptor deprecated 

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

Deprecated: Use NvmeControllerSpec.ProtoReflect.Descriptor instead.

func (*NvmeControllerSpec) GetCqes 

func (x *NvmeControllerSpec) GetCqes() int32

func (*NvmeControllerSpec) GetEndpoint 

func (m *NvmeControllerSpec) GetEndpoint() isNvmeControllerSpec_Endpoint

func (*NvmeControllerSpec) GetFabricsId 

func (x *NvmeControllerSpec) GetFabricsId() *FabricsEndpoint

func (*NvmeControllerSpec) GetMaxLimit 

func (x *NvmeControllerSpec) GetMaxLimit() *QosLimit

func (*NvmeControllerSpec) GetMaxNamespaces 

func (x *NvmeControllerSpec) GetMaxNamespaces() int32

func (*NvmeControllerSpec) GetMaxNcq 

func (x *NvmeControllerSpec) GetMaxNcq() int32

func (*NvmeControllerSpec) GetMaxNsq 

func (x *NvmeControllerSpec) GetMaxNsq() int32

func (*NvmeControllerSpec) GetMinLimit 

func (x *NvmeControllerSpec) GetMinLimit() *QosLimit

func (*NvmeControllerSpec) GetNvmeControllerId 

func (x *NvmeControllerSpec) GetNvmeControllerId() int32

func (*NvmeControllerSpec) GetPcieId 

func (x *NvmeControllerSpec) GetPcieId() *PciEndpoint

func (*NvmeControllerSpec) GetSqes 

func (x *NvmeControllerSpec) GetSqes() int32

func (*NvmeControllerSpec) GetTrtype 

func (x *NvmeControllerSpec) GetTrtype() NvmeTransportType

func (*NvmeControllerSpec) ProtoMessage 

func (*NvmeControllerSpec) ProtoMessage()

func (*NvmeControllerSpec) ProtoReflect 

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

func (*NvmeControllerSpec) Reset 

func (x *NvmeControllerSpec) Reset()

func (*NvmeControllerSpec) String 

func (x *NvmeControllerSpec) String() string

type NvmeControllerSpec_FabricsId 

type NvmeControllerSpec_FabricsId struct {
	// Required for Nvme over fabrics transport types to create
	// Nvme over Fabrics controllers to expose for example local SSDs over a network
	FabricsId *FabricsEndpoint `protobuf:"bytes,4,opt,name=fabrics_id,json=fabricsId,proto3,oneof"`
}

type NvmeControllerSpec_PcieId 

type NvmeControllerSpec_PcieId struct {
	// Required for pcie transport type to expose emulated Pcie Nvme controllers to Host
	PcieId *PciEndpoint `protobuf:"bytes,3,opt,name=pcie_id,json=pcieId,proto3,oneof"`
}

type NvmeControllerStatus 

type NvmeControllerStatus struct {

	// Device is in use by host nvme driver
	Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Controller status

func (*NvmeControllerStatus) Descriptor deprecated 

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

Deprecated: Use NvmeControllerStatus.ProtoReflect.Descriptor instead.

func (*NvmeControllerStatus) GetActive 

func (x *NvmeControllerStatus) GetActive() bool

func (*NvmeControllerStatus) ProtoMessage 

func (*NvmeControllerStatus) ProtoMessage()

func (*NvmeControllerStatus) ProtoReflect 

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

func (*NvmeControllerStatus) Reset 

func (x *NvmeControllerStatus) Reset()

func (*NvmeControllerStatus) String 

func (x *NvmeControllerStatus) String() string

type NvmeMultipath 

type NvmeMultipath int32

Multipath mode value options 

const (
	// Multipath mode is not specified
	NvmeMultipath_NVME_MULTIPATH_UNSPECIFIED NvmeMultipath = 0
	// Multipathing is disabled
	NvmeMultipath_NVME_MULTIPATH_DISABLE NvmeMultipath = 1
	// Failover mode where only one active connection is maintained and
	// path is changed only at switch-over
	NvmeMultipath_NVME_MULTIPATH_FAILOVER NvmeMultipath = 2
	// Multipath mode where active connections are maintained for every path
	NvmeMultipath_NVME_MULTIPATH_MULTIPATH NvmeMultipath = 3
)

func (NvmeMultipath) Descriptor 

func (NvmeMultipath) Descriptor() protoreflect.EnumDescriptor

func (NvmeMultipath) Enum 

func (x NvmeMultipath) Enum() *NvmeMultipath

func (NvmeMultipath) EnumDescriptor deprecated 

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

Deprecated: Use NvmeMultipath.Descriptor instead.

func (NvmeMultipath) Number 

func (x NvmeMultipath) Number() protoreflect.EnumNumber

func (NvmeMultipath) String 

func (x NvmeMultipath) String() string

func (NvmeMultipath) Type 

func (NvmeMultipath) Type() protoreflect.EnumType

type NvmeNamespace 

type NvmeNamespace struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// spec holds configurable values
	Spec *NvmeNamespaceSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	// status holds server generated values
	Status *NvmeNamespaceStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Namespace

func (*NvmeNamespace) Descriptor deprecated 

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

Deprecated: Use NvmeNamespace.ProtoReflect.Descriptor instead.

func (*NvmeNamespace) GetName 

func (x *NvmeNamespace) GetName() string

func (*NvmeNamespace) GetSpec 

func (x *NvmeNamespace) GetSpec() *NvmeNamespaceSpec

func (*NvmeNamespace) GetStatus 

func (x *NvmeNamespace) GetStatus() *NvmeNamespaceStatus

func (*NvmeNamespace) ProtoMessage 

func (*NvmeNamespace) ProtoMessage()

func (*NvmeNamespace) ProtoReflect 

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

func (*NvmeNamespace) Reset 

func (x *NvmeNamespace) Reset()

func (*NvmeNamespace) String 

func (x *NvmeNamespace) String() string

type NvmeNamespaceSpec 

type NvmeNamespaceSpec struct {

	// NSID presented by the Nvme controller.
	// If not provided, then the controller will assign an unused NSID
	// within the max namespace range - auto assigned nsid may not work
	// for live migration
	HostNsid int32 `protobuf:"varint,2,opt,name=host_nsid,json=hostNsid,proto3" json:"host_nsid,omitempty"`
	// Globally unique identifier for the namespace
	Nguid string `protobuf:"bytes,3,opt,name=nguid,proto3" json:"nguid,omitempty"`
	// 64bit Extended unique identifier for the namespace
	// mandatory if guid is not specified
	Eui64 int64 `protobuf:"varint,4,opt,name=eui64,proto3" json:"eui64,omitempty"`
	// Globally unique identifier for the namespace
	Uuid string `protobuf:"bytes,5,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// The back/middle-end volume to back this namespace.
	VolumeNameRef string `protobuf:"bytes,6,opt,name=volume_name_ref,json=volumeNameRef,proto3" json:"volume_name_ref,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Namespace configuration

func (*NvmeNamespaceSpec) Descriptor deprecated 

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

Deprecated: Use NvmeNamespaceSpec.ProtoReflect.Descriptor instead.

func (*NvmeNamespaceSpec) GetEui64 

func (x *NvmeNamespaceSpec) GetEui64() int64

func (*NvmeNamespaceSpec) GetHostNsid 

func (x *NvmeNamespaceSpec) GetHostNsid() int32

func (*NvmeNamespaceSpec) GetNguid 

func (x *NvmeNamespaceSpec) GetNguid() string

func (*NvmeNamespaceSpec) GetUuid 

func (x *NvmeNamespaceSpec) GetUuid() string

func (*NvmeNamespaceSpec) GetVolumeNameRef 

func (x *NvmeNamespaceSpec) GetVolumeNameRef() string

func (*NvmeNamespaceSpec) ProtoMessage 

func (*NvmeNamespaceSpec) ProtoMessage()

func (*NvmeNamespaceSpec) ProtoReflect 

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

func (*NvmeNamespaceSpec) Reset 

func (x *NvmeNamespaceSpec) Reset()

func (*NvmeNamespaceSpec) String 

func (x *NvmeNamespaceSpec) String() string

type NvmeNamespaceStatus 

type NvmeNamespaceStatus struct {

	// State of the namespace object, (enabled, disable, deleting)
	State NvmeNamespaceStatus_State `protobuf:"varint,1,opt,name=state,proto3,enum=opi_api.storage.v1.NvmeNamespaceStatus_State" json:"state,omitempty"`
	// Operational state of the namespace object, (connected, disconnected)
	OperState NvmeNamespaceStatus_OperState `` /* 143-byte string literal not displayed */
	// contains filtered or unexported fields
}

Represents Nvme Namespace status

func (*NvmeNamespaceStatus) Descriptor deprecated 

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

Deprecated: Use NvmeNamespaceStatus.ProtoReflect.Descriptor instead.

func (*NvmeNamespaceStatus) GetOperState 

func (x *NvmeNamespaceStatus) GetOperState() NvmeNamespaceStatus_OperState

func (*NvmeNamespaceStatus) GetState 

func (x *NvmeNamespaceStatus) GetState() NvmeNamespaceStatus_State

func (*NvmeNamespaceStatus) ProtoMessage 

func (*NvmeNamespaceStatus) ProtoMessage()

func (*NvmeNamespaceStatus) ProtoReflect 

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

func (*NvmeNamespaceStatus) Reset 

func (x *NvmeNamespaceStatus) Reset()

func (*NvmeNamespaceStatus) String 

func (x *NvmeNamespaceStatus) String() string

type NvmeNamespaceStatus_OperState 

type NvmeNamespaceStatus_OperState int32

Namespace operational states 

const (
	// unspecified
	NvmeNamespaceStatus_OPER_STATE_UNSPECIFIED NvmeNamespaceStatus_OperState = 0
	// namespace is online and operational
	NvmeNamespaceStatus_OPER_STATE_ONLINE NvmeNamespaceStatus_OperState = 1
	// namespace is offline
	NvmeNamespaceStatus_OPER_STATE_OFFLINE NvmeNamespaceStatus_OperState = 2
)

func (NvmeNamespaceStatus_OperState) Descriptor 

func (NvmeNamespaceStatus_OperState) Descriptor() protoreflect.EnumDescriptor

func (NvmeNamespaceStatus_OperState) Enum 

func (x NvmeNamespaceStatus_OperState) Enum() *NvmeNamespaceStatus_OperState

func (NvmeNamespaceStatus_OperState) EnumDescriptor deprecated 

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

Deprecated: Use NvmeNamespaceStatus_OperState.Descriptor instead.

func (NvmeNamespaceStatus_OperState) Number 

func (x NvmeNamespaceStatus_OperState) Number() protoreflect.EnumNumber

func (NvmeNamespaceStatus_OperState) String 

func (x NvmeNamespaceStatus_OperState) String() string

func (NvmeNamespaceStatus_OperState) Type 

func (NvmeNamespaceStatus_OperState) Type() protoreflect.EnumType

type NvmeNamespaceStatus_State 

type NvmeNamespaceStatus_State int32

Namespace Administrative States 

const (
	// unspecified
	NvmeNamespaceStatus_STATE_UNSPECIFIED NvmeNamespaceStatus_State = 0
	// namespace disabled state
	NvmeNamespaceStatus_STATE_DISABLED NvmeNamespaceStatus_State = 1
	// namespace enabled state
	NvmeNamespaceStatus_STATE_ENABLED NvmeNamespaceStatus_State = 2
	// namespace being deleted
	NvmeNamespaceStatus_STATE_DELETING NvmeNamespaceStatus_State = 3
)

func (NvmeNamespaceStatus_State) Descriptor 

func (NvmeNamespaceStatus_State) Descriptor() protoreflect.EnumDescriptor

func (NvmeNamespaceStatus_State) Enum 

func (x NvmeNamespaceStatus_State) Enum() *NvmeNamespaceStatus_State

func (NvmeNamespaceStatus_State) EnumDescriptor deprecated 

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

Deprecated: Use NvmeNamespaceStatus_State.Descriptor instead.

func (NvmeNamespaceStatus_State) Number 

func (x NvmeNamespaceStatus_State) Number() protoreflect.EnumNumber

func (NvmeNamespaceStatus_State) String 

func (x NvmeNamespaceStatus_State) String() string

func (NvmeNamespaceStatus_State) Type 

func (NvmeNamespaceStatus_State) Type() protoreflect.EnumType

type NvmePath 

type NvmePath struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Transport type
	Trtype NvmeTransportType `protobuf:"varint,2,opt,name=trtype,proto3,enum=opi_api.storage.v1.NvmeTransportType" json:"trtype,omitempty"`
	// Destination address (e.g. IP address, BDF for local PCIe)
	Traddr string `protobuf:"bytes,3,opt,name=traddr,proto3" json:"traddr,omitempty"`
	// Not applicable for local PCIe. Required for Nvme over fabrics transport types
	Fabrics *FabricsPath `protobuf:"bytes,4,opt,name=fabrics,proto3" json:"fabrics,omitempty"`
	// contains filtered or unexported fields
}

Represents a specific path to target controller

func (*NvmePath) Descriptor deprecated 

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

Deprecated: Use NvmePath.ProtoReflect.Descriptor instead.

func (*NvmePath) GetFabrics 

func (x *NvmePath) GetFabrics() *FabricsPath

func (*NvmePath) GetName 

func (x *NvmePath) GetName() string

func (*NvmePath) GetTraddr 

func (x *NvmePath) GetTraddr() string

func (*NvmePath) GetTrtype 

func (x *NvmePath) GetTrtype() NvmeTransportType

func (*NvmePath) ProtoMessage 

func (*NvmePath) ProtoMessage()

func (*NvmePath) ProtoReflect 

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

func (*NvmePath) Reset 

func (x *NvmePath) Reset()

func (*NvmePath) String 

func (x *NvmePath) String() string

type NvmeRemoteController 

type NvmeRemoteController struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Multipath mode
	Multipath NvmeMultipath `protobuf:"varint,2,opt,name=multipath,proto3,enum=opi_api.storage.v1.NvmeMultipath" json:"multipath,omitempty"`
	// IO queues count
	IoQueuesCount int64 `protobuf:"varint,3,opt,name=io_queues_count,json=ioQueuesCount,proto3" json:"io_queues_count,omitempty"`
	// Queue size
	QueueSize int64 `protobuf:"varint,4,opt,name=queue_size,json=queueSize,proto3" json:"queue_size,omitempty"`
	// Nvme over TCP specific fields
	Tcp *TcpController `protobuf:"bytes,5,opt,name=tcp,proto3" json:"tcp,omitempty"`
	// contains filtered or unexported fields
}

Represents a target controller

func (*NvmeRemoteController) Descriptor deprecated 

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

Deprecated: Use NvmeRemoteController.ProtoReflect.Descriptor instead.

func (*NvmeRemoteController) GetIoQueuesCount 

func (x *NvmeRemoteController) GetIoQueuesCount() int64

func (*NvmeRemoteController) GetMultipath 

func (x *NvmeRemoteController) GetMultipath() NvmeMultipath

func (*NvmeRemoteController) GetName 

func (x *NvmeRemoteController) GetName() string

func (*NvmeRemoteController) GetQueueSize 

func (x *NvmeRemoteController) GetQueueSize() int64

func (*NvmeRemoteController) GetTcp 

func (x *NvmeRemoteController) GetTcp() *TcpController

func (*NvmeRemoteController) ProtoMessage 

func (*NvmeRemoteController) ProtoMessage()

func (*NvmeRemoteController) ProtoReflect 

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

func (*NvmeRemoteController) Reset 

func (x *NvmeRemoteController) Reset()

func (*NvmeRemoteController) String 

func (x *NvmeRemoteController) String() string

type NvmeRemoteControllerServiceClient 

type NvmeRemoteControllerServiceClient interface {
	// Create an Nvme Remote Controller
	CreateNvmeRemoteController(ctx context.Context, in *CreateNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*NvmeRemoteController, error)
	// Delete an Nvme Remote Controller
	DeleteNvmeRemoteController(ctx context.Context, in *DeleteNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Nvme Remote Controller
	UpdateNvmeRemoteController(ctx context.Context, in *UpdateNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*NvmeRemoteController, error)
	// List Nvme Remote Controllers
	ListNvmeRemoteControllers(ctx context.Context, in *ListNvmeRemoteControllersRequest, opts ...grpc.CallOption) (*ListNvmeRemoteControllersResponse, error)
	// Get an Nvme Remote Controller
	GetNvmeRemoteController(ctx context.Context, in *GetNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*NvmeRemoteController, error)
	// Reset an Nvme Remote Controller
	ResetNvmeRemoteController(ctx context.Context, in *ResetNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Get an Nvme Remote Controller statistics
	StatsNvmeRemoteController(ctx context.Context, in *StatsNvmeRemoteControllerRequest, opts ...grpc.CallOption) (*StatsNvmeRemoteControllerResponse, error)
	// List Nvme Remote Namespaces
	ListNvmeRemoteNamespaces(ctx context.Context, in *ListNvmeRemoteNamespacesRequest, opts ...grpc.CallOption) (*ListNvmeRemoteNamespacesResponse, error)
	// Get an Nvme Remote Namespace
	GetNvmeRemoteNamespace(ctx context.Context, in *GetNvmeRemoteNamespaceRequest, opts ...grpc.CallOption) (*NvmeRemoteNamespace, error)
	// Create an Nvme Path
	CreateNvmePath(ctx context.Context, in *CreateNvmePathRequest, opts ...grpc.CallOption) (*NvmePath, error)
	// Delete an Nvme Path
	DeleteNvmePath(ctx context.Context, in *DeleteNvmePathRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Update an Nvme Path
	UpdateNvmePath(ctx context.Context, in *UpdateNvmePathRequest, opts ...grpc.CallOption) (*NvmePath, error)
	// List Nvme Paths
	ListNvmePaths(ctx context.Context, in *ListNvmePathsRequest, opts ...grpc.CallOption) (*ListNvmePathsResponse, error)
	// Get an Nvme Path
	GetNvmePath(ctx context.Context, in *GetNvmePathRequest, opts ...grpc.CallOption) (*NvmePath, error)
	// Get an Nvme Path statistics
	StatsNvmePath(ctx context.Context, in *StatsNvmePathRequest, opts ...grpc.CallOption) (*StatsNvmePathResponse, error)
}

NvmeRemoteControllerServiceClient is the client API for NvmeRemoteControllerService 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 NewNvmeRemoteControllerServiceClient 

func NewNvmeRemoteControllerServiceClient(cc grpc.ClientConnInterface) NvmeRemoteControllerServiceClient

type NvmeRemoteControllerServiceServer 

type NvmeRemoteControllerServiceServer interface {
	// Create an Nvme Remote Controller
	CreateNvmeRemoteController(context.Context, *CreateNvmeRemoteControllerRequest) (*NvmeRemoteController, error)
	// Delete an Nvme Remote Controller
	DeleteNvmeRemoteController(context.Context, *DeleteNvmeRemoteControllerRequest) (*emptypb.Empty, error)
	// Update an Nvme Remote Controller
	UpdateNvmeRemoteController(context.Context, *UpdateNvmeRemoteControllerRequest) (*NvmeRemoteController, error)
	// List Nvme Remote Controllers
	ListNvmeRemoteControllers(context.Context, *ListNvmeRemoteControllersRequest) (*ListNvmeRemoteControllersResponse, error)
	// Get an Nvme Remote Controller
	GetNvmeRemoteController(context.Context, *GetNvmeRemoteControllerRequest) (*NvmeRemoteController, error)
	// Reset an Nvme Remote Controller
	ResetNvmeRemoteController(context.Context, *ResetNvmeRemoteControllerRequest) (*emptypb.Empty, error)
	// Get an Nvme Remote Controller statistics
	StatsNvmeRemoteController(context.Context, *StatsNvmeRemoteControllerRequest) (*StatsNvmeRemoteControllerResponse, error)
	// List Nvme Remote Namespaces
	ListNvmeRemoteNamespaces(context.Context, *ListNvmeRemoteNamespacesRequest) (*ListNvmeRemoteNamespacesResponse, error)
	// Get an Nvme Remote Namespace
	GetNvmeRemoteNamespace(context.Context, *GetNvmeRemoteNamespaceRequest) (*NvmeRemoteNamespace, error)
	// Create an Nvme Path
	CreateNvmePath(context.Context, *CreateNvmePathRequest) (*NvmePath, error)
	// Delete an Nvme Path
	DeleteNvmePath(context.Context, *DeleteNvmePathRequest) (*emptypb.Empty, error)
	// Update an Nvme Path
	UpdateNvmePath(context.Context, *UpdateNvmePathRequest) (*NvmePath, error)
	// List Nvme Paths
	ListNvmePaths(context.Context, *ListNvmePathsRequest) (*ListNvmePathsResponse, error)
	// Get an Nvme Path
	GetNvmePath(context.Context, *GetNvmePathRequest) (*NvmePath, error)
	// Get an Nvme Path statistics
	StatsNvmePath(context.Context, *StatsNvmePathRequest) (*StatsNvmePathResponse, error)
	// contains filtered or unexported methods
}

NvmeRemoteControllerServiceServer is the server API for NvmeRemoteControllerService service. All implementations must embed UnimplementedNvmeRemoteControllerServiceServer for forward compatibility

type NvmeRemoteNamespace 

type NvmeRemoteNamespace struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// NSID
	Nsid int32 `protobuf:"varint,2,opt,name=nsid,proto3" json:"nsid,omitempty"`
	// Globally unique identifier for the namespace
	Nguid string `protobuf:"bytes,3,opt,name=nguid,proto3" json:"nguid,omitempty"`
	// 64bit Extended unique identifier for the namespace
	// mandatory if guid is not specified
	Eui64 int64 `protobuf:"varint,4,opt,name=eui64,proto3" json:"eui64,omitempty"`
	// Globally unique identifier for the namespace
	Uuid string `protobuf:"bytes,5,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// contains filtered or unexported fields
}

Represent Nvme namespace created on bridge after connection to a target

func (*NvmeRemoteNamespace) Descriptor deprecated 

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

Deprecated: Use NvmeRemoteNamespace.ProtoReflect.Descriptor instead.

func (*NvmeRemoteNamespace) GetEui64 

func (x *NvmeRemoteNamespace) GetEui64() int64

func (*NvmeRemoteNamespace) GetName 

func (x *NvmeRemoteNamespace) GetName() string

func (*NvmeRemoteNamespace) GetNguid 

func (x *NvmeRemoteNamespace) GetNguid() string

func (*NvmeRemoteNamespace) GetNsid 

func (x *NvmeRemoteNamespace) GetNsid() int32

func (*NvmeRemoteNamespace) GetUuid 

func (x *NvmeRemoteNamespace) GetUuid() string

func (*NvmeRemoteNamespace) ProtoMessage 

func (*NvmeRemoteNamespace) ProtoMessage()

func (*NvmeRemoteNamespace) ProtoReflect 

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

func (*NvmeRemoteNamespace) Reset 

func (x *NvmeRemoteNamespace) Reset()

func (*NvmeRemoteNamespace) String 

func (x *NvmeRemoteNamespace) String() string

type NvmeSubsystem 

type NvmeSubsystem struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// spec holds configurable values
	Spec *NvmeSubsystemSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	// status holds server generated values
	Status *NvmeSubsystemStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Subsystem

func (*NvmeSubsystem) Descriptor deprecated 

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

Deprecated: Use NvmeSubsystem.ProtoReflect.Descriptor instead.

func (*NvmeSubsystem) GetName 

func (x *NvmeSubsystem) GetName() string

func (*NvmeSubsystem) GetSpec 

func (x *NvmeSubsystem) GetSpec() *NvmeSubsystemSpec

func (*NvmeSubsystem) GetStatus 

func (x *NvmeSubsystem) GetStatus() *NvmeSubsystemStatus

func (*NvmeSubsystem) ProtoMessage 

func (*NvmeSubsystem) ProtoMessage()

func (*NvmeSubsystem) ProtoReflect 

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

func (*NvmeSubsystem) Reset 

func (x *NvmeSubsystem) Reset()

func (*NvmeSubsystem) String 

func (x *NvmeSubsystem) String() string

type NvmeSubsystemSpec 

type NvmeSubsystemSpec struct {

	// Nvme subsystem NQN to which the controller belongs
	// Refer to the NQN format in the Nvme base specifications, must not
	// exceed 'NSV_NVME_SUBSYSTEM_NQN_LEN' bytes
	Nqn string `protobuf:"bytes,1,opt,name=nqn,proto3" json:"nqn,omitempty"`
	// serial number must not exceed 'NSV_CTRLR_SERIAL_NO_LEN' bytes
	SerialNumber string `protobuf:"bytes,2,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	// model number, must not exceed 'NSV_CTRLR_MODEL_NO_LEN' bytes
	ModelNumber string `protobuf:"bytes,3,opt,name=model_number,json=modelNumber,proto3" json:"model_number,omitempty"`
	// maximum namespaces within a subsystem
	MaxNamespaces int64 `protobuf:"varint,4,opt,name=max_namespaces,json=maxNamespaces,proto3" json:"max_namespaces,omitempty"`
	// host NQN
	Hostnqn string `protobuf:"bytes,5,opt,name=hostnqn,proto3" json:"hostnqn,omitempty"`
	// psk key for TCP transport
	Psk []byte `protobuf:"bytes,6,opt,name=psk,proto3" json:"psk,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Subsystem configuration

func (*NvmeSubsystemSpec) Descriptor deprecated 

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

Deprecated: Use NvmeSubsystemSpec.ProtoReflect.Descriptor instead.

func (*NvmeSubsystemSpec) GetHostnqn 

func (x *NvmeSubsystemSpec) GetHostnqn() string

func (*NvmeSubsystemSpec) GetMaxNamespaces 

func (x *NvmeSubsystemSpec) GetMaxNamespaces() int64

func (*NvmeSubsystemSpec) GetModelNumber 

func (x *NvmeSubsystemSpec) GetModelNumber() string

func (*NvmeSubsystemSpec) GetNqn 

func (x *NvmeSubsystemSpec) GetNqn() string

func (*NvmeSubsystemSpec) GetPsk 

func (x *NvmeSubsystemSpec) GetPsk() []byte

func (*NvmeSubsystemSpec) GetSerialNumber 

func (x *NvmeSubsystemSpec) GetSerialNumber() string

func (*NvmeSubsystemSpec) ProtoMessage 

func (*NvmeSubsystemSpec) ProtoMessage()

func (*NvmeSubsystemSpec) ProtoReflect 

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

func (*NvmeSubsystemSpec) Reset 

func (x *NvmeSubsystemSpec) Reset()

func (*NvmeSubsystemSpec) String 

func (x *NvmeSubsystemSpec) String() string

type NvmeSubsystemStatus 

type NvmeSubsystemStatus struct {

	// firmware revision, must not exceed 'NSV_CTRLR_FW_REV_LEN'
	FirmwareRevision string `protobuf:"bytes,1,opt,name=firmware_revision,json=firmwareRevision,proto3" json:"firmware_revision,omitempty"`
	// FRU identfier, 16bytes opaque identity for the type of unit
	FruGuid []byte `protobuf:"bytes,2,opt,name=fru_guid,json=fruGuid,proto3" json:"fru_guid,omitempty"`
	// contains filtered or unexported fields
}

Represents Nvme Subsystem status

func (*NvmeSubsystemStatus) Descriptor deprecated 

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

Deprecated: Use NvmeSubsystemStatus.ProtoReflect.Descriptor instead.

func (*NvmeSubsystemStatus) GetFirmwareRevision 

func (x *NvmeSubsystemStatus) GetFirmwareRevision() string

func (*NvmeSubsystemStatus) GetFruGuid 

func (x *NvmeSubsystemStatus) GetFruGuid() []byte

func (*NvmeSubsystemStatus) ProtoMessage 

func (*NvmeSubsystemStatus) ProtoMessage()

func (*NvmeSubsystemStatus) ProtoReflect 

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

func (*NvmeSubsystemStatus) Reset 

func (x *NvmeSubsystemStatus) Reset()

func (*NvmeSubsystemStatus) String 

func (x *NvmeSubsystemStatus) String() string

type NvmeTransportType 

type NvmeTransportType int32

Transport type value options 

const (
	// Transport type is not specified
	NvmeTransportType_NVME_TRANSPORT_TYPE_UNSPECIFIED NvmeTransportType = 0
	// Fibre channel transport type
	NvmeTransportType_NVME_TRANSPORT_TYPE_FC NvmeTransportType = 1
	// Pcie transport type
	NvmeTransportType_NVME_TRANSPORT_TYPE_PCIE NvmeTransportType = 2
	// RDMA transport type
	NvmeTransportType_NVME_TRANSPORT_TYPE_RDMA NvmeTransportType = 3
	// TCP transport type
	NvmeTransportType_NVME_TRANSPORT_TYPE_TCP NvmeTransportType = 4
	// Custom transport type
	NvmeTransportType_NVME_TRANSPORT_TYPE_CUSTOM NvmeTransportType = 5
)

func (NvmeTransportType) Descriptor 

func (NvmeTransportType) Descriptor() protoreflect.EnumDescriptor

func (NvmeTransportType) Enum 

func (x NvmeTransportType) Enum() *NvmeTransportType

func (NvmeTransportType) EnumDescriptor deprecated 

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

Deprecated: Use NvmeTransportType.Descriptor instead.

func (NvmeTransportType) Number 

func (x NvmeTransportType) Number() protoreflect.EnumNumber

func (NvmeTransportType) String 

func (x NvmeTransportType) String() string

func (NvmeTransportType) Type 

func (NvmeTransportType) Type() protoreflect.EnumType

type PciEndpoint 

type PciEndpoint struct {

	// The "port" or "device". In other words, the connector/cable that's
	// plugged into a particular host. This number may end up matching
	// the host-assigned "device" value in the bus:device:function identifier,
	// but it does not strictly have to and that should not be relied upon.
	PortId *wrapperspb.Int32Value `protobuf:"bytes,1,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	// Physical function index. This may end up matching the host-assigned
	// "function" value in the bus:device:function identifier, but it does not
	// strictly have to and that should not be relied upon.
	PhysicalFunction *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=physical_function,json=physicalFunction,proto3" json:"physical_function,omitempty"`
	// Virtual function index. 1-based index.
	// The value 0 is reserved to represent the PCI physical "device".
	// This may end up matching the host-assigned "function" value in the
	// bus:device:function identifier, but it does not strictly have to and
	// that should not be relied upon.
	VirtualFunction *wrapperspb.Int32Value `protobuf:"bytes,3,opt,name=virtual_function,json=virtualFunction,proto3" json:"virtual_function,omitempty"`
	// contains filtered or unexported fields
}

Many front-ends expose PCI devices to the host. This represents that endpoint. This device will ultimately be surfaced by the operating system at some Bus:Device:Function, but note that the values set here are not necessarily the same values that the operating system will choose. Instead, these are xPU-internal values. While the term "device" is often used for the entity attached to a PCI slot, we'll use the term "port" which also commonly used with PCI switches and avoids confusion with storage "devices".

func (*PciEndpoint) Descriptor deprecated 

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

Deprecated: Use PciEndpoint.ProtoReflect.Descriptor instead.

func (*PciEndpoint) GetPhysicalFunction 

func (x *PciEndpoint) GetPhysicalFunction() *wrapperspb.Int32Value

func (*PciEndpoint) GetPortId 

func (x *PciEndpoint) GetPortId() *wrapperspb.Int32Value

func (*PciEndpoint) GetVirtualFunction 

func (x *PciEndpoint) GetVirtualFunction() *wrapperspb.Int32Value

func (*PciEndpoint) ProtoMessage 

func (*PciEndpoint) ProtoMessage()

func (*PciEndpoint) ProtoReflect 

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

func (*PciEndpoint) Reset 

func (x *PciEndpoint) Reset()

func (*PciEndpoint) String 

func (x *PciEndpoint) String() string

type QosLimit 

type QosLimit struct {

	// Read kIOPS
	RdIopsKiops int64 `protobuf:"varint,1,opt,name=rd_iops_kiops,json=rdIopsKiops,proto3" json:"rd_iops_kiops,omitempty"`
	// Write kIOPS
	WrIopsKiops int64 `protobuf:"varint,2,opt,name=wr_iops_kiops,json=wrIopsKiops,proto3" json:"wr_iops_kiops,omitempty"`
	// Read/write kIOPS
	RwIopsKiops int64 `protobuf:"varint,3,opt,name=rw_iops_kiops,json=rwIopsKiops,proto3" json:"rw_iops_kiops,omitempty"`
	// Read bandwidth (MB/s)
	RdBandwidthMbs int64 `protobuf:"varint,4,opt,name=rd_bandwidth_mbs,json=rdBandwidthMbs,proto3" json:"rd_bandwidth_mbs,omitempty"`
	// Write bandwidth (MB/s)
	WrBandwidthMbs int64 `protobuf:"varint,5,opt,name=wr_bandwidth_mbs,json=wrBandwidthMbs,proto3" json:"wr_bandwidth_mbs,omitempty"`
	// Read/write bandwidth (MB/s)
	RwBandwidthMbs int64 `protobuf:"varint,6,opt,name=rw_bandwidth_mbs,json=rwBandwidthMbs,proto3" json:"rw_bandwidth_mbs,omitempty"`
	// contains filtered or unexported fields
}

QoS limits applied to volumes/devices

func (*QosLimit) Descriptor deprecated 

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

Deprecated: Use QosLimit.ProtoReflect.Descriptor instead.

func (*QosLimit) GetRdBandwidthMbs 

func (x *QosLimit) GetRdBandwidthMbs() int64

func (*QosLimit) GetRdIopsKiops 

func (x *QosLimit) GetRdIopsKiops() int64

func (*QosLimit) GetRwBandwidthMbs 

func (x *QosLimit) GetRwBandwidthMbs() int64

func (*QosLimit) GetRwIopsKiops 

func (x *QosLimit) GetRwIopsKiops() int64

func (*QosLimit) GetWrBandwidthMbs 

func (x *QosLimit) GetWrBandwidthMbs() int64

func (*QosLimit) GetWrIopsKiops 

func (x *QosLimit) GetWrIopsKiops() int64

func (*QosLimit) ProtoMessage 

func (*QosLimit) ProtoMessage()

func (*QosLimit) ProtoReflect 

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

func (*QosLimit) Reset 

func (x *QosLimit) Reset()

func (*QosLimit) String 

func (x *QosLimit) String() string

type QosVolume 

type QosVolume struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Middleend/backend volume to apply QoS on
	VolumeNameRef string `protobuf:"bytes,2,opt,name=volume_name_ref,json=volumeNameRef,proto3" json:"volume_name_ref,omitempty"`
	// At least one limit value should be set, oitherwise volume does not make
	// sense.
	// AIP-203 says that a field should be described as REQUIRED if it is a
	// field on a resource that a user provides somewhere as input.
	// In this case, the resource is only valid if a "truthy" value is stored.
	// "truthy" is defined as:
	// * For primitives, values other than 0, 0.0, empty string/bytes, and false
	// * For repeated fields maps, values with at least one entry
	// * For messages, any message with at least one "truthy" field.
	// We cannot mark both min and max QosLimit as REQUIRED directly here, since
	// it forces one limit field is set on both. Limits message is added to
	// overcome it. REQUIRED on limits forces at least one limit field in
	// either min/max sub message is set.
	Limits *Limits `protobuf:"bytes,3,opt,name=limits,proto3" json:"limits,omitempty"`
	// contains filtered or unexported fields
}

Represents volume providing quality of service capabilities

func (*QosVolume) Descriptor deprecated 

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

Deprecated: Use QosVolume.ProtoReflect.Descriptor instead.

func (*QosVolume) GetLimits 

func (x *QosVolume) GetLimits() *Limits

func (*QosVolume) GetName 

func (x *QosVolume) GetName() string

func (*QosVolume) GetVolumeNameRef 

func (x *QosVolume) GetVolumeNameRef() string

func (*QosVolume) ProtoMessage 

func (*QosVolume) ProtoMessage()

func (*QosVolume) ProtoReflect 

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

func (*QosVolume) Reset 

func (x *QosVolume) Reset()

func (*QosVolume) String 

func (x *QosVolume) String() string

type ResetNvmeRemoteControllerRequest 

type ResetNvmeRemoteControllerRequest struct {

	// Object's unique identifier to reset
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to reset an Nvme Remote Controller.

func (*ResetNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use ResetNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*ResetNvmeRemoteControllerRequest) GetName 

func (x *ResetNvmeRemoteControllerRequest) GetName() string

func (*ResetNvmeRemoteControllerRequest) ProtoMessage 

func (*ResetNvmeRemoteControllerRequest) ProtoMessage()

func (*ResetNvmeRemoteControllerRequest) ProtoReflect 

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

func (*ResetNvmeRemoteControllerRequest) Reset 

func (x *ResetNvmeRemoteControllerRequest) Reset()

func (*ResetNvmeRemoteControllerRequest) String 

func (x *ResetNvmeRemoteControllerRequest) String() string

type StatsAioVolumeRequest 

type StatsAioVolumeRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Aio Volume statistics.

func (*StatsAioVolumeRequest) Descriptor deprecated 

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

Deprecated: Use StatsAioVolumeRequest.ProtoReflect.Descriptor instead.

func (*StatsAioVolumeRequest) GetName 

func (x *StatsAioVolumeRequest) GetName() string

func (*StatsAioVolumeRequest) ProtoMessage 

func (*StatsAioVolumeRequest) ProtoMessage()

func (*StatsAioVolumeRequest) ProtoReflect 

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

func (*StatsAioVolumeRequest) Reset 

func (x *StatsAioVolumeRequest) Reset()

func (*StatsAioVolumeRequest) String 

func (x *StatsAioVolumeRequest) String() string

type StatsAioVolumeResponse 

type StatsAioVolumeResponse struct {

	// Volume statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Aio Volume statistics.

func (*StatsAioVolumeResponse) Descriptor deprecated 

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

Deprecated: Use StatsAioVolumeResponse.ProtoReflect.Descriptor instead.

func (*StatsAioVolumeResponse) GetStats 

func (x *StatsAioVolumeResponse) GetStats() *VolumeStats

func (*StatsAioVolumeResponse) ProtoMessage 

func (*StatsAioVolumeResponse) ProtoMessage()

func (*StatsAioVolumeResponse) ProtoReflect 

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

func (*StatsAioVolumeResponse) Reset 

func (x *StatsAioVolumeResponse) Reset()

func (*StatsAioVolumeResponse) String 

func (x *StatsAioVolumeResponse) String() string

type StatsEncryptedVolumeRequest 

type StatsEncryptedVolumeRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Encrypted Volume statistics.

func (*StatsEncryptedVolumeRequest) Descriptor deprecated 

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

Deprecated: Use StatsEncryptedVolumeRequest.ProtoReflect.Descriptor instead.

func (*StatsEncryptedVolumeRequest) GetName 

func (x *StatsEncryptedVolumeRequest) GetName() string

func (*StatsEncryptedVolumeRequest) ProtoMessage 

func (*StatsEncryptedVolumeRequest) ProtoMessage()

func (*StatsEncryptedVolumeRequest) ProtoReflect 

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

func (*StatsEncryptedVolumeRequest) Reset 

func (x *StatsEncryptedVolumeRequest) Reset()

func (*StatsEncryptedVolumeRequest) String 

func (x *StatsEncryptedVolumeRequest) String() string

type StatsEncryptedVolumeResponse 

type StatsEncryptedVolumeResponse struct {

	// Volume statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Encrypted Volume statistics.

func (*StatsEncryptedVolumeResponse) Descriptor deprecated 

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

Deprecated: Use StatsEncryptedVolumeResponse.ProtoReflect.Descriptor instead.

func (*StatsEncryptedVolumeResponse) GetStats 

func (x *StatsEncryptedVolumeResponse) GetStats() *VolumeStats

func (*StatsEncryptedVolumeResponse) ProtoMessage 

func (*StatsEncryptedVolumeResponse) ProtoMessage()

func (*StatsEncryptedVolumeResponse) ProtoReflect 

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

func (*StatsEncryptedVolumeResponse) Reset 

func (x *StatsEncryptedVolumeResponse) Reset()

func (*StatsEncryptedVolumeResponse) String 

func (x *StatsEncryptedVolumeResponse) String() string

type StatsMallocVolumeRequest 

type StatsMallocVolumeRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get a Malloc Volume statistics.

func (*StatsMallocVolumeRequest) Descriptor deprecated 

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

Deprecated: Use StatsMallocVolumeRequest.ProtoReflect.Descriptor instead.

func (*StatsMallocVolumeRequest) GetName 

func (x *StatsMallocVolumeRequest) GetName() string

func (*StatsMallocVolumeRequest) ProtoMessage 

func (*StatsMallocVolumeRequest) ProtoMessage()

func (*StatsMallocVolumeRequest) ProtoReflect 

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

func (*StatsMallocVolumeRequest) Reset 

func (x *StatsMallocVolumeRequest) Reset()

func (*StatsMallocVolumeRequest) String 

func (x *StatsMallocVolumeRequest) String() string

type StatsMallocVolumeResponse 

type StatsMallocVolumeResponse struct {

	// Volume statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get a Malloc Volume statistics.

func (*StatsMallocVolumeResponse) Descriptor deprecated 

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

Deprecated: Use StatsMallocVolumeResponse.ProtoReflect.Descriptor instead.

func (*StatsMallocVolumeResponse) GetStats 

func (x *StatsMallocVolumeResponse) GetStats() *VolumeStats

func (*StatsMallocVolumeResponse) ProtoMessage 

func (*StatsMallocVolumeResponse) ProtoMessage()

func (*StatsMallocVolumeResponse) ProtoReflect 

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

func (*StatsMallocVolumeResponse) Reset 

func (x *StatsMallocVolumeResponse) Reset()

func (*StatsMallocVolumeResponse) String 

func (x *StatsMallocVolumeResponse) String() string

type StatsNullVolumeRequest 

type StatsNullVolumeRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Null Volume statistics.

func (*StatsNullVolumeRequest) Descriptor deprecated 

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

Deprecated: Use StatsNullVolumeRequest.ProtoReflect.Descriptor instead.

func (*StatsNullVolumeRequest) GetName 

func (x *StatsNullVolumeRequest) GetName() string

func (*StatsNullVolumeRequest) ProtoMessage 

func (*StatsNullVolumeRequest) ProtoMessage()

func (*StatsNullVolumeRequest) ProtoReflect 

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

func (*StatsNullVolumeRequest) Reset 

func (x *StatsNullVolumeRequest) Reset()

func (*StatsNullVolumeRequest) String 

func (x *StatsNullVolumeRequest) String() string

type StatsNullVolumeResponse 

type StatsNullVolumeResponse struct {

	// Volume statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Null Volume statistics.

func (*StatsNullVolumeResponse) Descriptor deprecated 

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

Deprecated: Use StatsNullVolumeResponse.ProtoReflect.Descriptor instead.

func (*StatsNullVolumeResponse) GetStats 

func (x *StatsNullVolumeResponse) GetStats() *VolumeStats

func (*StatsNullVolumeResponse) ProtoMessage 

func (*StatsNullVolumeResponse) ProtoMessage()

func (*StatsNullVolumeResponse) ProtoReflect 

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

func (*StatsNullVolumeResponse) Reset 

func (x *StatsNullVolumeResponse) Reset()

func (*StatsNullVolumeResponse) String 

func (x *StatsNullVolumeResponse) String() string

type StatsNvmeControllerRequest 

type StatsNvmeControllerRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Controller statistics.

func (*StatsNvmeControllerRequest) Descriptor deprecated 

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

Deprecated: Use StatsNvmeControllerRequest.ProtoReflect.Descriptor instead.

func (*StatsNvmeControllerRequest) GetName 

func (x *StatsNvmeControllerRequest) GetName() string

func (*StatsNvmeControllerRequest) ProtoMessage 

func (*StatsNvmeControllerRequest) ProtoMessage()

func (*StatsNvmeControllerRequest) ProtoReflect 

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

func (*StatsNvmeControllerRequest) Reset 

func (x *StatsNvmeControllerRequest) Reset()

func (*StatsNvmeControllerRequest) String 

func (x *StatsNvmeControllerRequest) String() string

type StatsNvmeControllerResponse 

type StatsNvmeControllerResponse struct {

	// Controller statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Nvme Controller statistics.

func (*StatsNvmeControllerResponse) Descriptor deprecated 

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

Deprecated: Use StatsNvmeControllerResponse.ProtoReflect.Descriptor instead.

func (*StatsNvmeControllerResponse) GetStats 

func (x *StatsNvmeControllerResponse) GetStats() *VolumeStats

func (*StatsNvmeControllerResponse) ProtoMessage 

func (*StatsNvmeControllerResponse) ProtoMessage()

func (*StatsNvmeControllerResponse) ProtoReflect 

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

func (*StatsNvmeControllerResponse) Reset 

func (x *StatsNvmeControllerResponse) Reset()

func (*StatsNvmeControllerResponse) String 

func (x *StatsNvmeControllerResponse) String() string

type StatsNvmeNamespaceRequest 

type StatsNvmeNamespaceRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Namespace statistics.

func (*StatsNvmeNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use StatsNvmeNamespaceRequest.ProtoReflect.Descriptor instead.

func (*StatsNvmeNamespaceRequest) GetName 

func (x *StatsNvmeNamespaceRequest) GetName() string

func (*StatsNvmeNamespaceRequest) ProtoMessage 

func (*StatsNvmeNamespaceRequest) ProtoMessage()

func (*StatsNvmeNamespaceRequest) ProtoReflect 

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

func (*StatsNvmeNamespaceRequest) Reset 

func (x *StatsNvmeNamespaceRequest) Reset()

func (*StatsNvmeNamespaceRequest) String 

func (x *StatsNvmeNamespaceRequest) String() string

type StatsNvmeNamespaceResponse 

type StatsNvmeNamespaceResponse struct {

	// Namespace statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Nvme Namespace statistics.

func (*StatsNvmeNamespaceResponse) Descriptor deprecated 

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

Deprecated: Use StatsNvmeNamespaceResponse.ProtoReflect.Descriptor instead.

func (*StatsNvmeNamespaceResponse) GetStats 

func (x *StatsNvmeNamespaceResponse) GetStats() *VolumeStats

func (*StatsNvmeNamespaceResponse) ProtoMessage 

func (*StatsNvmeNamespaceResponse) ProtoMessage()

func (*StatsNvmeNamespaceResponse) ProtoReflect 

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

func (*StatsNvmeNamespaceResponse) Reset 

func (x *StatsNvmeNamespaceResponse) Reset()

func (*StatsNvmeNamespaceResponse) String 

func (x *StatsNvmeNamespaceResponse) String() string

type StatsNvmePathRequest 

type StatsNvmePathRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Path statistics.

func (*StatsNvmePathRequest) Descriptor deprecated 

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

Deprecated: Use StatsNvmePathRequest.ProtoReflect.Descriptor instead.

func (*StatsNvmePathRequest) GetName 

func (x *StatsNvmePathRequest) GetName() string

func (*StatsNvmePathRequest) ProtoMessage 

func (*StatsNvmePathRequest) ProtoMessage()

func (*StatsNvmePathRequest) ProtoReflect 

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

func (*StatsNvmePathRequest) Reset 

func (x *StatsNvmePathRequest) Reset()

func (*StatsNvmePathRequest) String 

func (x *StatsNvmePathRequest) String() string

type StatsNvmePathResponse 

type StatsNvmePathResponse struct {

	// Path statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Nvme Path statistics.

func (*StatsNvmePathResponse) Descriptor deprecated 

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

Deprecated: Use StatsNvmePathResponse.ProtoReflect.Descriptor instead.

func (*StatsNvmePathResponse) GetStats 

func (x *StatsNvmePathResponse) GetStats() *VolumeStats

func (*StatsNvmePathResponse) ProtoMessage 

func (*StatsNvmePathResponse) ProtoMessage()

func (*StatsNvmePathResponse) ProtoReflect 

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

func (*StatsNvmePathResponse) Reset 

func (x *StatsNvmePathResponse) Reset()

func (*StatsNvmePathResponse) String 

func (x *StatsNvmePathResponse) String() string

type StatsNvmeRemoteControllerRequest 

type StatsNvmeRemoteControllerRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Remote Controller statistics.

func (*StatsNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use StatsNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*StatsNvmeRemoteControllerRequest) GetName 

func (x *StatsNvmeRemoteControllerRequest) GetName() string

func (*StatsNvmeRemoteControllerRequest) ProtoMessage 

func (*StatsNvmeRemoteControllerRequest) ProtoMessage()

func (*StatsNvmeRemoteControllerRequest) ProtoReflect 

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

func (*StatsNvmeRemoteControllerRequest) Reset 

func (x *StatsNvmeRemoteControllerRequest) Reset()

func (*StatsNvmeRemoteControllerRequest) String 

func (x *StatsNvmeRemoteControllerRequest) String() string

type StatsNvmeRemoteControllerResponse 

type StatsNvmeRemoteControllerResponse struct {

	// Controller statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Nvme Remote Controller statistics.

func (*StatsNvmeRemoteControllerResponse) Descriptor deprecated 

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

Deprecated: Use StatsNvmeRemoteControllerResponse.ProtoReflect.Descriptor instead.

func (*StatsNvmeRemoteControllerResponse) GetStats 

func (x *StatsNvmeRemoteControllerResponse) GetStats() *VolumeStats

func (*StatsNvmeRemoteControllerResponse) ProtoMessage 

func (*StatsNvmeRemoteControllerResponse) ProtoMessage()

func (*StatsNvmeRemoteControllerResponse) ProtoReflect 

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

func (*StatsNvmeRemoteControllerResponse) Reset 

func (x *StatsNvmeRemoteControllerResponse) Reset()

func (*StatsNvmeRemoteControllerResponse) String 

func (x *StatsNvmeRemoteControllerResponse) String() string

type StatsNvmeSubsystemRequest 

type StatsNvmeSubsystemRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Nvme Subsystems statistics.

func (*StatsNvmeSubsystemRequest) Descriptor deprecated 

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

Deprecated: Use StatsNvmeSubsystemRequest.ProtoReflect.Descriptor instead.

func (*StatsNvmeSubsystemRequest) GetName 

func (x *StatsNvmeSubsystemRequest) GetName() string

func (*StatsNvmeSubsystemRequest) ProtoMessage 

func (*StatsNvmeSubsystemRequest) ProtoMessage()

func (*StatsNvmeSubsystemRequest) ProtoReflect 

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

func (*StatsNvmeSubsystemRequest) Reset 

func (x *StatsNvmeSubsystemRequest) Reset()

func (*StatsNvmeSubsystemRequest) String 

func (x *StatsNvmeSubsystemRequest) String() string

type StatsNvmeSubsystemResponse 

type StatsNvmeSubsystemResponse struct {

	// Subsystem statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Nvme Subsystems statistics.

func (*StatsNvmeSubsystemResponse) Descriptor deprecated 

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

Deprecated: Use StatsNvmeSubsystemResponse.ProtoReflect.Descriptor instead.

func (*StatsNvmeSubsystemResponse) GetStats 

func (x *StatsNvmeSubsystemResponse) GetStats() *VolumeStats

func (*StatsNvmeSubsystemResponse) ProtoMessage 

func (*StatsNvmeSubsystemResponse) ProtoMessage()

func (*StatsNvmeSubsystemResponse) ProtoReflect 

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

func (*StatsNvmeSubsystemResponse) Reset 

func (x *StatsNvmeSubsystemResponse) Reset()

func (*StatsNvmeSubsystemResponse) String 

func (x *StatsNvmeSubsystemResponse) String() string

type StatsQosVolumeRequest 

type StatsQosVolumeRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an QoS Volume statistics.

func (*StatsQosVolumeRequest) Descriptor deprecated 

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

Deprecated: Use StatsQosVolumeRequest.ProtoReflect.Descriptor instead.

func (*StatsQosVolumeRequest) GetName 

func (x *StatsQosVolumeRequest) GetName() string

func (*StatsQosVolumeRequest) ProtoMessage 

func (*StatsQosVolumeRequest) ProtoMessage()

func (*StatsQosVolumeRequest) ProtoReflect 

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

func (*StatsQosVolumeRequest) Reset 

func (x *StatsQosVolumeRequest) Reset()

func (*StatsQosVolumeRequest) String 

func (x *StatsQosVolumeRequest) String() string

type StatsQosVolumeResponse 

type StatsQosVolumeResponse struct {

	// Volume statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an QoS Volume statistics.

func (*StatsQosVolumeResponse) Descriptor deprecated 

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

Deprecated: Use StatsQosVolumeResponse.ProtoReflect.Descriptor instead.

func (*StatsQosVolumeResponse) GetStats 

func (x *StatsQosVolumeResponse) GetStats() *VolumeStats

func (*StatsQosVolumeResponse) ProtoMessage 

func (*StatsQosVolumeResponse) ProtoMessage()

func (*StatsQosVolumeResponse) ProtoReflect 

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

func (*StatsQosVolumeResponse) Reset 

func (x *StatsQosVolumeResponse) Reset()

func (*StatsQosVolumeResponse) String 

func (x *StatsQosVolumeResponse) String() string

type StatsVirtioBlkRequest 

type StatsVirtioBlkRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Blk statistics.

func (*StatsVirtioBlkRequest) Descriptor deprecated 

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

Deprecated: Use StatsVirtioBlkRequest.ProtoReflect.Descriptor instead.

func (*StatsVirtioBlkRequest) GetName 

func (x *StatsVirtioBlkRequest) GetName() string

func (*StatsVirtioBlkRequest) ProtoMessage 

func (*StatsVirtioBlkRequest) ProtoMessage()

func (*StatsVirtioBlkRequest) ProtoReflect 

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

func (*StatsVirtioBlkRequest) Reset 

func (x *StatsVirtioBlkRequest) Reset()

func (*StatsVirtioBlkRequest) String 

func (x *StatsVirtioBlkRequest) String() string

type StatsVirtioBlkResponse 

type StatsVirtioBlkResponse struct {

	// Device statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Virtio Blk statistics.

func (*StatsVirtioBlkResponse) Descriptor deprecated 

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

Deprecated: Use StatsVirtioBlkResponse.ProtoReflect.Descriptor instead.

func (*StatsVirtioBlkResponse) GetStats 

func (x *StatsVirtioBlkResponse) GetStats() *VolumeStats

func (*StatsVirtioBlkResponse) ProtoMessage 

func (*StatsVirtioBlkResponse) ProtoMessage()

func (*StatsVirtioBlkResponse) ProtoReflect 

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

func (*StatsVirtioBlkResponse) Reset 

func (x *StatsVirtioBlkResponse) Reset()

func (*StatsVirtioBlkResponse) String 

func (x *StatsVirtioBlkResponse) String() string

type StatsVirtioScsiControllerRequest 

type StatsVirtioScsiControllerRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Controller statistics.

func (*StatsVirtioScsiControllerRequest) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiControllerRequest.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiControllerRequest) GetName 

func (x *StatsVirtioScsiControllerRequest) GetName() string

func (*StatsVirtioScsiControllerRequest) ProtoMessage 

func (*StatsVirtioScsiControllerRequest) ProtoMessage()

func (*StatsVirtioScsiControllerRequest) ProtoReflect 

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

func (*StatsVirtioScsiControllerRequest) Reset 

func (x *StatsVirtioScsiControllerRequest) Reset()

func (*StatsVirtioScsiControllerRequest) String 

func (x *StatsVirtioScsiControllerRequest) String() string

type StatsVirtioScsiControllerResponse 

type StatsVirtioScsiControllerResponse struct {

	// Scsi Controller statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Virtio Scsi Controller statistics.

func (*StatsVirtioScsiControllerResponse) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiControllerResponse.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiControllerResponse) GetStats 

func (x *StatsVirtioScsiControllerResponse) GetStats() *VolumeStats

func (*StatsVirtioScsiControllerResponse) ProtoMessage 

func (*StatsVirtioScsiControllerResponse) ProtoMessage()

func (*StatsVirtioScsiControllerResponse) ProtoReflect 

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

func (*StatsVirtioScsiControllerResponse) Reset 

func (x *StatsVirtioScsiControllerResponse) Reset()

func (*StatsVirtioScsiControllerResponse) String 

func (x *StatsVirtioScsiControllerResponse) String() string

type StatsVirtioScsiLunRequest 

type StatsVirtioScsiLunRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Controller's uniqie identifier
	ControllerNameRef string `protobuf:"bytes,2,opt,name=controller_name_ref,json=controllerNameRef,proto3" json:"controller_name_ref,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Lun statistics.

func (*StatsVirtioScsiLunRequest) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiLunRequest.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiLunRequest) GetControllerNameRef 

func (x *StatsVirtioScsiLunRequest) GetControllerNameRef() string

func (*StatsVirtioScsiLunRequest) GetName 

func (x *StatsVirtioScsiLunRequest) GetName() string

func (*StatsVirtioScsiLunRequest) ProtoMessage 

func (*StatsVirtioScsiLunRequest) ProtoMessage()

func (*StatsVirtioScsiLunRequest) ProtoReflect 

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

func (*StatsVirtioScsiLunRequest) Reset 

func (x *StatsVirtioScsiLunRequest) Reset()

func (*StatsVirtioScsiLunRequest) String 

func (x *StatsVirtioScsiLunRequest) String() string

type StatsVirtioScsiLunResponse 

type StatsVirtioScsiLunResponse struct {

	// Scsi Lun statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Virtio Scsi Lun statistics.

func (*StatsVirtioScsiLunResponse) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiLunResponse.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiLunResponse) GetStats 

func (x *StatsVirtioScsiLunResponse) GetStats() *VolumeStats

func (*StatsVirtioScsiLunResponse) ProtoMessage 

func (*StatsVirtioScsiLunResponse) ProtoMessage()

func (*StatsVirtioScsiLunResponse) ProtoReflect 

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

func (*StatsVirtioScsiLunResponse) Reset 

func (x *StatsVirtioScsiLunResponse) Reset()

func (*StatsVirtioScsiLunResponse) String 

func (x *StatsVirtioScsiLunResponse) String() string

type StatsVirtioScsiTargetRequest 

type StatsVirtioScsiTargetRequest struct {

	// Object's unique identifier to retrieve statistics
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to get an Virtio Scsi Target statistics.

func (*StatsVirtioScsiTargetRequest) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiTargetRequest.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiTargetRequest) GetName 

func (x *StatsVirtioScsiTargetRequest) GetName() string

func (*StatsVirtioScsiTargetRequest) ProtoMessage 

func (*StatsVirtioScsiTargetRequest) ProtoMessage()

func (*StatsVirtioScsiTargetRequest) ProtoReflect 

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

func (*StatsVirtioScsiTargetRequest) Reset 

func (x *StatsVirtioScsiTargetRequest) Reset()

func (*StatsVirtioScsiTargetRequest) String 

func (x *StatsVirtioScsiTargetRequest) String() string

type StatsVirtioScsiTargetResponse 

type StatsVirtioScsiTargetResponse struct {

	// Scsi Target statistics
	Stats *VolumeStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

Represents a response to get an Virtio Scsi Target statistics.

func (*StatsVirtioScsiTargetResponse) Descriptor deprecated 

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

Deprecated: Use StatsVirtioScsiTargetResponse.ProtoReflect.Descriptor instead.

func (*StatsVirtioScsiTargetResponse) GetStats 

func (x *StatsVirtioScsiTargetResponse) GetStats() *VolumeStats

func (*StatsVirtioScsiTargetResponse) ProtoMessage 

func (*StatsVirtioScsiTargetResponse) ProtoMessage()

func (*StatsVirtioScsiTargetResponse) ProtoReflect 

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

func (*StatsVirtioScsiTargetResponse) Reset 

func (x *StatsVirtioScsiTargetResponse) Reset()

func (*StatsVirtioScsiTargetResponse) String 

func (x *StatsVirtioScsiTargetResponse) String() string

type TcpController 

type TcpController struct {

	// Header digest
	Hdgst bool `protobuf:"varint,1,opt,name=hdgst,proto3" json:"hdgst,omitempty"`
	// Data digest
	Ddgst bool `protobuf:"varint,2,opt,name=ddgst,proto3" json:"ddgst,omitempty"`
	// Nvme/TCP published secure channel specification (TP 8011) based on TLS 1.3 and PSK.
	// Use PSK interchange format with base64 encoding as input.
	// Also use information about hash function in interchange
	// format for retained PSK generation. If no hash is selected,
	// use configured PSK as retained PSK.
	// Check the size of interchange PSK to determine cipher suite.
	// Calculate CRC-32 bytes to ensure validity of PSK.
	// Example: "NVMeTLSkey-1:01:VRLbtnN9AQb2WXW3c9+wEf/DRLz0QuLdbYvEhwtdWwNf9LrZ:"
	// if PSK field is empty, then unsecure connection Nvme/TCP without TLS will be made
	Psk []byte `protobuf:"bytes,3,opt,name=psk,proto3" json:"psk,omitempty"`
	// contains filtered or unexported fields
}

Represents parameters specific for TCP target controller

func (*TcpController) Descriptor deprecated 

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

Deprecated: Use TcpController.ProtoReflect.Descriptor instead.

func (*TcpController) GetDdgst 

func (x *TcpController) GetDdgst() bool

func (*TcpController) GetHdgst 

func (x *TcpController) GetHdgst() bool

func (*TcpController) GetPsk 

func (x *TcpController) GetPsk() []byte

func (*TcpController) ProtoMessage 

func (*TcpController) ProtoMessage()

func (*TcpController) ProtoReflect 

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

func (*TcpController) Reset 

func (x *TcpController) Reset()

func (*TcpController) String 

func (x *TcpController) String() string

type UnimplementedAioVolumeServiceServer 

type UnimplementedAioVolumeServiceServer struct {
}

UnimplementedAioVolumeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedAioVolumeServiceServer) CreateAioVolume 

func (UnimplementedAioVolumeServiceServer) CreateAioVolume(context.Context, *CreateAioVolumeRequest) (*AioVolume, error)

func (UnimplementedAioVolumeServiceServer) DeleteAioVolume 

func (UnimplementedAioVolumeServiceServer) DeleteAioVolume(context.Context, *DeleteAioVolumeRequest) (*emptypb.Empty, error)

func (UnimplementedAioVolumeServiceServer) GetAioVolume 

func (UnimplementedAioVolumeServiceServer) GetAioVolume(context.Context, *GetAioVolumeRequest) (*AioVolume, error)

func (UnimplementedAioVolumeServiceServer) ListAioVolumes 

func (UnimplementedAioVolumeServiceServer) ListAioVolumes(context.Context, *ListAioVolumesRequest) (*ListAioVolumesResponse, error)

func (UnimplementedAioVolumeServiceServer) StatsAioVolume 

func (UnimplementedAioVolumeServiceServer) StatsAioVolume(context.Context, *StatsAioVolumeRequest) (*StatsAioVolumeResponse, error)

func (UnimplementedAioVolumeServiceServer) UpdateAioVolume 

func (UnimplementedAioVolumeServiceServer) UpdateAioVolume(context.Context, *UpdateAioVolumeRequest) (*AioVolume, error)

type UnimplementedFrontendNvmeServiceServer 

type UnimplementedFrontendNvmeServiceServer struct {
}

UnimplementedFrontendNvmeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeController 

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeController(context.Context, *CreateNvmeControllerRequest) (*NvmeController, error)

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeNamespace 

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeNamespace(context.Context, *CreateNvmeNamespaceRequest) (*NvmeNamespace, error)

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeSubsystem 

func (UnimplementedFrontendNvmeServiceServer) CreateNvmeSubsystem(context.Context, *CreateNvmeSubsystemRequest) (*NvmeSubsystem, error)

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeController 

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeController(context.Context, *DeleteNvmeControllerRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeNamespace 

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeNamespace(context.Context, *DeleteNvmeNamespaceRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeSubsystem 

func (UnimplementedFrontendNvmeServiceServer) DeleteNvmeSubsystem(context.Context, *DeleteNvmeSubsystemRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendNvmeServiceServer) GetNvmeController 

func (UnimplementedFrontendNvmeServiceServer) GetNvmeController(context.Context, *GetNvmeControllerRequest) (*NvmeController, error)

func (UnimplementedFrontendNvmeServiceServer) GetNvmeNamespace 

func (UnimplementedFrontendNvmeServiceServer) GetNvmeNamespace(context.Context, *GetNvmeNamespaceRequest) (*NvmeNamespace, error)

func (UnimplementedFrontendNvmeServiceServer) GetNvmeSubsystem 

func (UnimplementedFrontendNvmeServiceServer) GetNvmeSubsystem(context.Context, *GetNvmeSubsystemRequest) (*NvmeSubsystem, error)

func (UnimplementedFrontendNvmeServiceServer) ListNvmeControllers 

func (UnimplementedFrontendNvmeServiceServer) ListNvmeControllers(context.Context, *ListNvmeControllersRequest) (*ListNvmeControllersResponse, error)

func (UnimplementedFrontendNvmeServiceServer) ListNvmeNamespaces 

func (UnimplementedFrontendNvmeServiceServer) ListNvmeNamespaces(context.Context, *ListNvmeNamespacesRequest) (*ListNvmeNamespacesResponse, error)

func (UnimplementedFrontendNvmeServiceServer) ListNvmeSubsystems 

func (UnimplementedFrontendNvmeServiceServer) ListNvmeSubsystems(context.Context, *ListNvmeSubsystemsRequest) (*ListNvmeSubsystemsResponse, error)

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeController 

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeController(context.Context, *StatsNvmeControllerRequest) (*StatsNvmeControllerResponse, error)

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeNamespace 

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeNamespace(context.Context, *StatsNvmeNamespaceRequest) (*StatsNvmeNamespaceResponse, error)

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeSubsystem 

func (UnimplementedFrontendNvmeServiceServer) StatsNvmeSubsystem(context.Context, *StatsNvmeSubsystemRequest) (*StatsNvmeSubsystemResponse, error)

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeController 

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeController(context.Context, *UpdateNvmeControllerRequest) (*NvmeController, error)

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeNamespace 

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeNamespace(context.Context, *UpdateNvmeNamespaceRequest) (*NvmeNamespace, error)

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeSubsystem 

func (UnimplementedFrontendNvmeServiceServer) UpdateNvmeSubsystem(context.Context, *UpdateNvmeSubsystemRequest) (*NvmeSubsystem, error)

type UnimplementedFrontendVirtioBlkServiceServer 

type UnimplementedFrontendVirtioBlkServiceServer struct {
}

UnimplementedFrontendVirtioBlkServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedFrontendVirtioBlkServiceServer) CreateVirtioBlk 

func (UnimplementedFrontendVirtioBlkServiceServer) CreateVirtioBlk(context.Context, *CreateVirtioBlkRequest) (*VirtioBlk, error)

func (UnimplementedFrontendVirtioBlkServiceServer) DeleteVirtioBlk 

func (UnimplementedFrontendVirtioBlkServiceServer) DeleteVirtioBlk(context.Context, *DeleteVirtioBlkRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendVirtioBlkServiceServer) GetVirtioBlk 

func (UnimplementedFrontendVirtioBlkServiceServer) GetVirtioBlk(context.Context, *GetVirtioBlkRequest) (*VirtioBlk, error)

func (UnimplementedFrontendVirtioBlkServiceServer) ListVirtioBlks 

func (UnimplementedFrontendVirtioBlkServiceServer) ListVirtioBlks(context.Context, *ListVirtioBlksRequest) (*ListVirtioBlksResponse, error)

func (UnimplementedFrontendVirtioBlkServiceServer) StatsVirtioBlk 

func (UnimplementedFrontendVirtioBlkServiceServer) StatsVirtioBlk(context.Context, *StatsVirtioBlkRequest) (*StatsVirtioBlkResponse, error)

func (UnimplementedFrontendVirtioBlkServiceServer) UpdateVirtioBlk 

func (UnimplementedFrontendVirtioBlkServiceServer) UpdateVirtioBlk(context.Context, *UpdateVirtioBlkRequest) (*VirtioBlk, error)

type UnimplementedFrontendVirtioScsiServiceServer 

type UnimplementedFrontendVirtioScsiServiceServer struct {
}

UnimplementedFrontendVirtioScsiServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiController 

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiController(context.Context, *CreateVirtioScsiControllerRequest) (*VirtioScsiController, error)

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiLun 

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiLun(context.Context, *CreateVirtioScsiLunRequest) (*VirtioScsiLun, error)

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiTarget 

func (UnimplementedFrontendVirtioScsiServiceServer) CreateVirtioScsiTarget(context.Context, *CreateVirtioScsiTargetRequest) (*VirtioScsiTarget, error)

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiController 

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiController(context.Context, *DeleteVirtioScsiControllerRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiLun 

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiLun(context.Context, *DeleteVirtioScsiLunRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiTarget 

func (UnimplementedFrontendVirtioScsiServiceServer) DeleteVirtioScsiTarget(context.Context, *DeleteVirtioScsiTargetRequest) (*emptypb.Empty, error)

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiController 

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiController(context.Context, *GetVirtioScsiControllerRequest) (*VirtioScsiController, error)

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiLun 

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiLun(context.Context, *GetVirtioScsiLunRequest) (*VirtioScsiLun, error)

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiTarget 

func (UnimplementedFrontendVirtioScsiServiceServer) GetVirtioScsiTarget(context.Context, *GetVirtioScsiTargetRequest) (*VirtioScsiTarget, error)

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiControllers 

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiControllers(context.Context, *ListVirtioScsiControllersRequest) (*ListVirtioScsiControllersResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiLuns 

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiLuns(context.Context, *ListVirtioScsiLunsRequest) (*ListVirtioScsiLunsResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiTargets 

func (UnimplementedFrontendVirtioScsiServiceServer) ListVirtioScsiTargets(context.Context, *ListVirtioScsiTargetsRequest) (*ListVirtioScsiTargetsResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiController 

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiController(context.Context, *StatsVirtioScsiControllerRequest) (*StatsVirtioScsiControllerResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiLun 

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiLun(context.Context, *StatsVirtioScsiLunRequest) (*StatsVirtioScsiLunResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiTarget 

func (UnimplementedFrontendVirtioScsiServiceServer) StatsVirtioScsiTarget(context.Context, *StatsVirtioScsiTargetRequest) (*StatsVirtioScsiTargetResponse, error)

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiController 

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiController(context.Context, *UpdateVirtioScsiControllerRequest) (*VirtioScsiController, error)

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiLun 

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiLun(context.Context, *UpdateVirtioScsiLunRequest) (*VirtioScsiLun, error)

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiTarget 

func (UnimplementedFrontendVirtioScsiServiceServer) UpdateVirtioScsiTarget(context.Context, *UpdateVirtioScsiTargetRequest) (*VirtioScsiTarget, error)

type UnimplementedMallocVolumeServiceServer 

type UnimplementedMallocVolumeServiceServer struct {
}

UnimplementedMallocVolumeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedMallocVolumeServiceServer) CreateMallocVolume 

func (UnimplementedMallocVolumeServiceServer) CreateMallocVolume(context.Context, *CreateMallocVolumeRequest) (*MallocVolume, error)

func (UnimplementedMallocVolumeServiceServer) DeleteMallocVolume 

func (UnimplementedMallocVolumeServiceServer) DeleteMallocVolume(context.Context, *DeleteMallocVolumeRequest) (*emptypb.Empty, error)

func (UnimplementedMallocVolumeServiceServer) GetMallocVolume 

func (UnimplementedMallocVolumeServiceServer) GetMallocVolume(context.Context, *GetMallocVolumeRequest) (*MallocVolume, error)

func (UnimplementedMallocVolumeServiceServer) ListMallocVolumes 

func (UnimplementedMallocVolumeServiceServer) ListMallocVolumes(context.Context, *ListMallocVolumesRequest) (*ListMallocVolumesResponse, error)

func (UnimplementedMallocVolumeServiceServer) StatsMallocVolume 

func (UnimplementedMallocVolumeServiceServer) StatsMallocVolume(context.Context, *StatsMallocVolumeRequest) (*StatsMallocVolumeResponse, error)

func (UnimplementedMallocVolumeServiceServer) UpdateMallocVolume 

func (UnimplementedMallocVolumeServiceServer) UpdateMallocVolume(context.Context, *UpdateMallocVolumeRequest) (*MallocVolume, error)

type UnimplementedMiddleendEncryptionServiceServer 

type UnimplementedMiddleendEncryptionServiceServer struct {
}

UnimplementedMiddleendEncryptionServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedMiddleendEncryptionServiceServer) CreateEncryptedVolume 

func (UnimplementedMiddleendEncryptionServiceServer) CreateEncryptedVolume(context.Context, *CreateEncryptedVolumeRequest) (*EncryptedVolume, error)

func (UnimplementedMiddleendEncryptionServiceServer) DeleteEncryptedVolume 

func (UnimplementedMiddleendEncryptionServiceServer) DeleteEncryptedVolume(context.Context, *DeleteEncryptedVolumeRequest) (*emptypb.Empty, error)

func (UnimplementedMiddleendEncryptionServiceServer) GetEncryptedVolume 

func (UnimplementedMiddleendEncryptionServiceServer) GetEncryptedVolume(context.Context, *GetEncryptedVolumeRequest) (*EncryptedVolume, error)

func (UnimplementedMiddleendEncryptionServiceServer) ListEncryptedVolumes 

func (UnimplementedMiddleendEncryptionServiceServer) ListEncryptedVolumes(context.Context, *ListEncryptedVolumesRequest) (*ListEncryptedVolumesResponse, error)

func (UnimplementedMiddleendEncryptionServiceServer) StatsEncryptedVolume 

func (UnimplementedMiddleendEncryptionServiceServer) StatsEncryptedVolume(context.Context, *StatsEncryptedVolumeRequest) (*StatsEncryptedVolumeResponse, error)

func (UnimplementedMiddleendEncryptionServiceServer) UpdateEncryptedVolume 

func (UnimplementedMiddleendEncryptionServiceServer) UpdateEncryptedVolume(context.Context, *UpdateEncryptedVolumeRequest) (*EncryptedVolume, error)

type UnimplementedMiddleendQosVolumeServiceServer 

type UnimplementedMiddleendQosVolumeServiceServer struct {
}

UnimplementedMiddleendQosVolumeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedMiddleendQosVolumeServiceServer) CreateQosVolume 

func (UnimplementedMiddleendQosVolumeServiceServer) CreateQosVolume(context.Context, *CreateQosVolumeRequest) (*QosVolume, error)

func (UnimplementedMiddleendQosVolumeServiceServer) DeleteQosVolume 

func (UnimplementedMiddleendQosVolumeServiceServer) DeleteQosVolume(context.Context, *DeleteQosVolumeRequest) (*emptypb.Empty, error)

func (UnimplementedMiddleendQosVolumeServiceServer) GetQosVolume 

func (UnimplementedMiddleendQosVolumeServiceServer) GetQosVolume(context.Context, *GetQosVolumeRequest) (*QosVolume, error)

func (UnimplementedMiddleendQosVolumeServiceServer) ListQosVolumes 

func (UnimplementedMiddleendQosVolumeServiceServer) ListQosVolumes(context.Context, *ListQosVolumesRequest) (*ListQosVolumesResponse, error)

func (UnimplementedMiddleendQosVolumeServiceServer) StatsQosVolume 

func (UnimplementedMiddleendQosVolumeServiceServer) StatsQosVolume(context.Context, *StatsQosVolumeRequest) (*StatsQosVolumeResponse, error)

func (UnimplementedMiddleendQosVolumeServiceServer) UpdateQosVolume 

func (UnimplementedMiddleendQosVolumeServiceServer) UpdateQosVolume(context.Context, *UpdateQosVolumeRequest) (*QosVolume, error)

type UnimplementedNullVolumeServiceServer 

type UnimplementedNullVolumeServiceServer struct {
}

UnimplementedNullVolumeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedNullVolumeServiceServer) CreateNullVolume 

func (UnimplementedNullVolumeServiceServer) CreateNullVolume(context.Context, *CreateNullVolumeRequest) (*NullVolume, error)

func (UnimplementedNullVolumeServiceServer) DeleteNullVolume 

func (UnimplementedNullVolumeServiceServer) DeleteNullVolume(context.Context, *DeleteNullVolumeRequest) (*emptypb.Empty, error)

func (UnimplementedNullVolumeServiceServer) GetNullVolume 

func (UnimplementedNullVolumeServiceServer) GetNullVolume(context.Context, *GetNullVolumeRequest) (*NullVolume, error)

func (UnimplementedNullVolumeServiceServer) ListNullVolumes 

func (UnimplementedNullVolumeServiceServer) ListNullVolumes(context.Context, *ListNullVolumesRequest) (*ListNullVolumesResponse, error)

func (UnimplementedNullVolumeServiceServer) StatsNullVolume 

func (UnimplementedNullVolumeServiceServer) StatsNullVolume(context.Context, *StatsNullVolumeRequest) (*StatsNullVolumeResponse, error)

func (UnimplementedNullVolumeServiceServer) UpdateNullVolume 

func (UnimplementedNullVolumeServiceServer) UpdateNullVolume(context.Context, *UpdateNullVolumeRequest) (*NullVolume, error)

type UnimplementedNvmeRemoteControllerServiceServer 

type UnimplementedNvmeRemoteControllerServiceServer struct {
}

UnimplementedNvmeRemoteControllerServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedNvmeRemoteControllerServiceServer) CreateNvmePath 

func (UnimplementedNvmeRemoteControllerServiceServer) CreateNvmePath(context.Context, *CreateNvmePathRequest) (*NvmePath, error)

func (UnimplementedNvmeRemoteControllerServiceServer) CreateNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) CreateNvmeRemoteController(context.Context, *CreateNvmeRemoteControllerRequest) (*NvmeRemoteController, error)

func (UnimplementedNvmeRemoteControllerServiceServer) DeleteNvmePath 

func (UnimplementedNvmeRemoteControllerServiceServer) DeleteNvmePath(context.Context, *DeleteNvmePathRequest) (*emptypb.Empty, error)

func (UnimplementedNvmeRemoteControllerServiceServer) DeleteNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) DeleteNvmeRemoteController(context.Context, *DeleteNvmeRemoteControllerRequest) (*emptypb.Empty, error)

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmePath 

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmePath(context.Context, *GetNvmePathRequest) (*NvmePath, error)

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmeRemoteController(context.Context, *GetNvmeRemoteControllerRequest) (*NvmeRemoteController, error)

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmeRemoteNamespace 

func (UnimplementedNvmeRemoteControllerServiceServer) GetNvmeRemoteNamespace(context.Context, *GetNvmeRemoteNamespaceRequest) (*NvmeRemoteNamespace, error)

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmePaths 

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmePaths(context.Context, *ListNvmePathsRequest) (*ListNvmePathsResponse, error)

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmeRemoteControllers 

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmeRemoteControllers(context.Context, *ListNvmeRemoteControllersRequest) (*ListNvmeRemoteControllersResponse, error)

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmeRemoteNamespaces 

func (UnimplementedNvmeRemoteControllerServiceServer) ListNvmeRemoteNamespaces(context.Context, *ListNvmeRemoteNamespacesRequest) (*ListNvmeRemoteNamespacesResponse, error)

func (UnimplementedNvmeRemoteControllerServiceServer) ResetNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) ResetNvmeRemoteController(context.Context, *ResetNvmeRemoteControllerRequest) (*emptypb.Empty, error)

func (UnimplementedNvmeRemoteControllerServiceServer) StatsNvmePath 

func (UnimplementedNvmeRemoteControllerServiceServer) StatsNvmePath(context.Context, *StatsNvmePathRequest) (*StatsNvmePathResponse, error)

func (UnimplementedNvmeRemoteControllerServiceServer) StatsNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) StatsNvmeRemoteController(context.Context, *StatsNvmeRemoteControllerRequest) (*StatsNvmeRemoteControllerResponse, error)

func (UnimplementedNvmeRemoteControllerServiceServer) UpdateNvmePath 

func (UnimplementedNvmeRemoteControllerServiceServer) UpdateNvmePath(context.Context, *UpdateNvmePathRequest) (*NvmePath, error)

func (UnimplementedNvmeRemoteControllerServiceServer) UpdateNvmeRemoteController 

func (UnimplementedNvmeRemoteControllerServiceServer) UpdateNvmeRemoteController(context.Context, *UpdateNvmeRemoteControllerRequest) (*NvmeRemoteController, error)

type UnsafeAioVolumeServiceServer 

type UnsafeAioVolumeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAioVolumeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AioVolumeServiceServer will result in compilation errors.

type UnsafeFrontendNvmeServiceServer 

type UnsafeFrontendNvmeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeFrontendNvmeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to FrontendNvmeServiceServer will result in compilation errors.

type UnsafeFrontendVirtioBlkServiceServer 

type UnsafeFrontendVirtioBlkServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeFrontendVirtioBlkServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to FrontendVirtioBlkServiceServer will result in compilation errors.

type UnsafeFrontendVirtioScsiServiceServer 

type UnsafeFrontendVirtioScsiServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeFrontendVirtioScsiServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to FrontendVirtioScsiServiceServer will result in compilation errors.

type UnsafeMallocVolumeServiceServer 

type UnsafeMallocVolumeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMallocVolumeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MallocVolumeServiceServer will result in compilation errors.

type UnsafeMiddleendEncryptionServiceServer 

type UnsafeMiddleendEncryptionServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMiddleendEncryptionServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MiddleendEncryptionServiceServer will result in compilation errors.

type UnsafeMiddleendQosVolumeServiceServer 

type UnsafeMiddleendQosVolumeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMiddleendQosVolumeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MiddleendQosVolumeServiceServer will result in compilation errors.

type UnsafeNullVolumeServiceServer 

type UnsafeNullVolumeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNullVolumeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NullVolumeServiceServer will result in compilation errors.

type UnsafeNvmeRemoteControllerServiceServer 

type UnsafeNvmeRemoteControllerServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNvmeRemoteControllerServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NvmeRemoteControllerServiceServer will result in compilation errors.

type UpdateAioVolumeRequest 

type UpdateAioVolumeRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	AioVolume *AioVolume `protobuf:"bytes,1,opt,name=aio_volume,json=aioVolume,proto3" json:"aio_volume,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Aio Volume.

func (*UpdateAioVolumeRequest) Descriptor deprecated 

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

Deprecated: Use UpdateAioVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateAioVolumeRequest) GetAioVolume 

func (x *UpdateAioVolumeRequest) GetAioVolume() *AioVolume

func (*UpdateAioVolumeRequest) GetAllowMissing 

func (x *UpdateAioVolumeRequest) GetAllowMissing() bool

func (*UpdateAioVolumeRequest) GetUpdateMask 

func (x *UpdateAioVolumeRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateAioVolumeRequest) ProtoMessage 

func (*UpdateAioVolumeRequest) ProtoMessage()

func (*UpdateAioVolumeRequest) ProtoReflect 

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

func (*UpdateAioVolumeRequest) Reset 

func (x *UpdateAioVolumeRequest) Reset()

func (*UpdateAioVolumeRequest) String 

func (x *UpdateAioVolumeRequest) String() string

type UpdateEncryptedVolumeRequest 

type UpdateEncryptedVolumeRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	EncryptedVolume *EncryptedVolume `protobuf:"bytes,1,opt,name=encrypted_volume,json=encryptedVolume,proto3" json:"encrypted_volume,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Encrypted Volume.

func (*UpdateEncryptedVolumeRequest) Descriptor deprecated 

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

Deprecated: Use UpdateEncryptedVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateEncryptedVolumeRequest) GetAllowMissing 

func (x *UpdateEncryptedVolumeRequest) GetAllowMissing() bool

func (*UpdateEncryptedVolumeRequest) GetEncryptedVolume 

func (x *UpdateEncryptedVolumeRequest) GetEncryptedVolume() *EncryptedVolume

func (*UpdateEncryptedVolumeRequest) GetUpdateMask 

func (x *UpdateEncryptedVolumeRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateEncryptedVolumeRequest) ProtoMessage 

func (*UpdateEncryptedVolumeRequest) ProtoMessage()

func (*UpdateEncryptedVolumeRequest) ProtoReflect 

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

func (*UpdateEncryptedVolumeRequest) Reset 

func (x *UpdateEncryptedVolumeRequest) Reset()

func (*UpdateEncryptedVolumeRequest) String 

func (x *UpdateEncryptedVolumeRequest) String() string

type UpdateMallocVolumeRequest 

type UpdateMallocVolumeRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	MallocVolume *MallocVolume `protobuf:"bytes,1,opt,name=malloc_volume,json=mallocVolume,proto3" json:"malloc_volume,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update a Malloc Volume.

func (*UpdateMallocVolumeRequest) Descriptor deprecated 

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

Deprecated: Use UpdateMallocVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateMallocVolumeRequest) GetAllowMissing 

func (x *UpdateMallocVolumeRequest) GetAllowMissing() bool

func (*UpdateMallocVolumeRequest) GetMallocVolume 

func (x *UpdateMallocVolumeRequest) GetMallocVolume() *MallocVolume

func (*UpdateMallocVolumeRequest) GetUpdateMask 

func (x *UpdateMallocVolumeRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateMallocVolumeRequest) ProtoMessage 

func (*UpdateMallocVolumeRequest) ProtoMessage()

func (*UpdateMallocVolumeRequest) ProtoReflect 

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

func (*UpdateMallocVolumeRequest) Reset 

func (x *UpdateMallocVolumeRequest) Reset()

func (*UpdateMallocVolumeRequest) String 

func (x *UpdateMallocVolumeRequest) String() string

type UpdateNullVolumeRequest 

type UpdateNullVolumeRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NullVolume *NullVolume `protobuf:"bytes,1,opt,name=null_volume,json=nullVolume,proto3" json:"null_volume,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Null Volume.

func (*UpdateNullVolumeRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNullVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateNullVolumeRequest) GetAllowMissing 

func (x *UpdateNullVolumeRequest) GetAllowMissing() bool

func (*UpdateNullVolumeRequest) GetNullVolume 

func (x *UpdateNullVolumeRequest) GetNullVolume() *NullVolume

func (*UpdateNullVolumeRequest) GetUpdateMask 

func (x *UpdateNullVolumeRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNullVolumeRequest) ProtoMessage 

func (*UpdateNullVolumeRequest) ProtoMessage()

func (*UpdateNullVolumeRequest) ProtoReflect 

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

func (*UpdateNullVolumeRequest) Reset 

func (x *UpdateNullVolumeRequest) Reset()

func (*UpdateNullVolumeRequest) String 

func (x *UpdateNullVolumeRequest) String() string

type UpdateNvmeControllerRequest 

type UpdateNvmeControllerRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NvmeController *NvmeController `protobuf:"bytes,1,opt,name=nvme_controller,json=nvmeController,proto3" json:"nvme_controller,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Nvme Controller.

func (*UpdateNvmeControllerRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNvmeControllerRequest.ProtoReflect.Descriptor instead.

func (*UpdateNvmeControllerRequest) GetAllowMissing 

func (x *UpdateNvmeControllerRequest) GetAllowMissing() bool

func (*UpdateNvmeControllerRequest) GetNvmeController 

func (x *UpdateNvmeControllerRequest) GetNvmeController() *NvmeController

func (*UpdateNvmeControllerRequest) GetUpdateMask 

func (x *UpdateNvmeControllerRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNvmeControllerRequest) ProtoMessage 

func (*UpdateNvmeControllerRequest) ProtoMessage()

func (*UpdateNvmeControllerRequest) ProtoReflect 

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

func (*UpdateNvmeControllerRequest) Reset 

func (x *UpdateNvmeControllerRequest) Reset()

func (*UpdateNvmeControllerRequest) String 

func (x *UpdateNvmeControllerRequest) String() string

type UpdateNvmeNamespaceRequest 

type UpdateNvmeNamespaceRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NvmeNamespace *NvmeNamespace `protobuf:"bytes,1,opt,name=nvme_namespace,json=nvmeNamespace,proto3" json:"nvme_namespace,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Nvme Namespace.

func (*UpdateNvmeNamespaceRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNvmeNamespaceRequest.ProtoReflect.Descriptor instead.

func (*UpdateNvmeNamespaceRequest) GetAllowMissing 

func (x *UpdateNvmeNamespaceRequest) GetAllowMissing() bool

func (*UpdateNvmeNamespaceRequest) GetNvmeNamespace 

func (x *UpdateNvmeNamespaceRequest) GetNvmeNamespace() *NvmeNamespace

func (*UpdateNvmeNamespaceRequest) GetUpdateMask 

func (x *UpdateNvmeNamespaceRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNvmeNamespaceRequest) ProtoMessage 

func (*UpdateNvmeNamespaceRequest) ProtoMessage()

func (*UpdateNvmeNamespaceRequest) ProtoReflect 

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

func (*UpdateNvmeNamespaceRequest) Reset 

func (x *UpdateNvmeNamespaceRequest) Reset()

func (*UpdateNvmeNamespaceRequest) String 

func (x *UpdateNvmeNamespaceRequest) String() string

type UpdateNvmePathRequest 

type UpdateNvmePathRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NvmePath *NvmePath `protobuf:"bytes,1,opt,name=nvme_path,json=nvmePath,proto3" json:"nvme_path,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Nvme Path.

func (*UpdateNvmePathRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNvmePathRequest.ProtoReflect.Descriptor instead.

func (*UpdateNvmePathRequest) GetAllowMissing 

func (x *UpdateNvmePathRequest) GetAllowMissing() bool

func (*UpdateNvmePathRequest) GetNvmePath 

func (x *UpdateNvmePathRequest) GetNvmePath() *NvmePath

func (*UpdateNvmePathRequest) GetUpdateMask 

func (x *UpdateNvmePathRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNvmePathRequest) ProtoMessage 

func (*UpdateNvmePathRequest) ProtoMessage()

func (*UpdateNvmePathRequest) ProtoReflect 

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

func (*UpdateNvmePathRequest) Reset 

func (x *UpdateNvmePathRequest) Reset()

func (*UpdateNvmePathRequest) String 

func (x *UpdateNvmePathRequest) String() string

type UpdateNvmeRemoteControllerRequest 

type UpdateNvmeRemoteControllerRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NvmeRemoteController *NvmeRemoteController `protobuf:"bytes,1,opt,name=nvme_remote_controller,json=nvmeRemoteController,proto3" json:"nvme_remote_controller,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Nvme Remote Controller.

func (*UpdateNvmeRemoteControllerRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNvmeRemoteControllerRequest.ProtoReflect.Descriptor instead.

func (*UpdateNvmeRemoteControllerRequest) GetAllowMissing 

func (x *UpdateNvmeRemoteControllerRequest) GetAllowMissing() bool

func (*UpdateNvmeRemoteControllerRequest) GetNvmeRemoteController 

func (x *UpdateNvmeRemoteControllerRequest) GetNvmeRemoteController() *NvmeRemoteController

func (*UpdateNvmeRemoteControllerRequest) GetUpdateMask 

func (x *UpdateNvmeRemoteControllerRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNvmeRemoteControllerRequest) ProtoMessage 

func (*UpdateNvmeRemoteControllerRequest) ProtoMessage()

func (*UpdateNvmeRemoteControllerRequest) ProtoReflect 

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

func (*UpdateNvmeRemoteControllerRequest) Reset 

func (x *UpdateNvmeRemoteControllerRequest) Reset()

func (*UpdateNvmeRemoteControllerRequest) String 

func (x *UpdateNvmeRemoteControllerRequest) String() string

type UpdateNvmeSubsystemRequest 

type UpdateNvmeSubsystemRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	NvmeSubsystem *NvmeSubsystem `protobuf:"bytes,1,opt,name=nvme_subsystem,json=nvmeSubsystem,proto3" json:"nvme_subsystem,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Nvme Subsystem.

func (*UpdateNvmeSubsystemRequest) Descriptor deprecated 

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

Deprecated: Use UpdateNvmeSubsystemRequest.ProtoReflect.Descriptor instead.

func (*UpdateNvmeSubsystemRequest) GetAllowMissing 

func (x *UpdateNvmeSubsystemRequest) GetAllowMissing() bool

func (*UpdateNvmeSubsystemRequest) GetNvmeSubsystem 

func (x *UpdateNvmeSubsystemRequest) GetNvmeSubsystem() *NvmeSubsystem

func (*UpdateNvmeSubsystemRequest) GetUpdateMask 

func (x *UpdateNvmeSubsystemRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateNvmeSubsystemRequest) ProtoMessage 

func (*UpdateNvmeSubsystemRequest) ProtoMessage()

func (*UpdateNvmeSubsystemRequest) ProtoReflect 

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

func (*UpdateNvmeSubsystemRequest) Reset 

func (x *UpdateNvmeSubsystemRequest) Reset()

func (*UpdateNvmeSubsystemRequest) String 

func (x *UpdateNvmeSubsystemRequest) String() string

type UpdateQosVolumeRequest 

type UpdateQosVolumeRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	QosVolume *QosVolume `protobuf:"bytes,1,opt,name=qos_volume,json=qosVolume,proto3" json:"qos_volume,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an QoS Volume.

func (*UpdateQosVolumeRequest) Descriptor deprecated 

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

Deprecated: Use UpdateQosVolumeRequest.ProtoReflect.Descriptor instead.

func (*UpdateQosVolumeRequest) GetAllowMissing 

func (x *UpdateQosVolumeRequest) GetAllowMissing() bool

func (*UpdateQosVolumeRequest) GetQosVolume 

func (x *UpdateQosVolumeRequest) GetQosVolume() *QosVolume

func (*UpdateQosVolumeRequest) GetUpdateMask 

func (x *UpdateQosVolumeRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateQosVolumeRequest) ProtoMessage 

func (*UpdateQosVolumeRequest) ProtoMessage()

func (*UpdateQosVolumeRequest) ProtoReflect 

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

func (*UpdateQosVolumeRequest) Reset 

func (x *UpdateQosVolumeRequest) Reset()

func (*UpdateQosVolumeRequest) String 

func (x *UpdateQosVolumeRequest) String() string

type UpdateVirtioBlkRequest 

type UpdateVirtioBlkRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	VirtioBlk *VirtioBlk `protobuf:"bytes,1,opt,name=virtio_blk,json=virtioBlk,proto3" json:"virtio_blk,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Virtio Blk.

func (*UpdateVirtioBlkRequest) Descriptor deprecated 

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

Deprecated: Use UpdateVirtioBlkRequest.ProtoReflect.Descriptor instead.

func (*UpdateVirtioBlkRequest) GetAllowMissing 

func (x *UpdateVirtioBlkRequest) GetAllowMissing() bool

func (*UpdateVirtioBlkRequest) GetUpdateMask 

func (x *UpdateVirtioBlkRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateVirtioBlkRequest) GetVirtioBlk 

func (x *UpdateVirtioBlkRequest) GetVirtioBlk() *VirtioBlk

func (*UpdateVirtioBlkRequest) ProtoMessage 

func (*UpdateVirtioBlkRequest) ProtoMessage()

func (*UpdateVirtioBlkRequest) ProtoReflect 

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

func (*UpdateVirtioBlkRequest) Reset 

func (x *UpdateVirtioBlkRequest) Reset()

func (*UpdateVirtioBlkRequest) String 

func (x *UpdateVirtioBlkRequest) String() string

type UpdateVirtioScsiControllerRequest 

type UpdateVirtioScsiControllerRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	VirtioScsiController *VirtioScsiController `protobuf:"bytes,1,opt,name=virtio_scsi_controller,json=virtioScsiController,proto3" json:"virtio_scsi_controller,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Virtio Scsi Controller.

func (*UpdateVirtioScsiControllerRequest) Descriptor deprecated 

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

Deprecated: Use UpdateVirtioScsiControllerRequest.ProtoReflect.Descriptor instead.

func (*UpdateVirtioScsiControllerRequest) GetAllowMissing 

func (x *UpdateVirtioScsiControllerRequest) GetAllowMissing() bool

func (*UpdateVirtioScsiControllerRequest) GetUpdateMask 

func (x *UpdateVirtioScsiControllerRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateVirtioScsiControllerRequest) GetVirtioScsiController 

func (x *UpdateVirtioScsiControllerRequest) GetVirtioScsiController() *VirtioScsiController

func (*UpdateVirtioScsiControllerRequest) ProtoMessage 

func (*UpdateVirtioScsiControllerRequest) ProtoMessage()

func (*UpdateVirtioScsiControllerRequest) ProtoReflect 

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

func (*UpdateVirtioScsiControllerRequest) Reset 

func (x *UpdateVirtioScsiControllerRequest) Reset()

func (*UpdateVirtioScsiControllerRequest) String 

func (x *UpdateVirtioScsiControllerRequest) String() string

type UpdateVirtioScsiLunRequest 

type UpdateVirtioScsiLunRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	VirtioScsiLun *VirtioScsiLun `protobuf:"bytes,1,opt,name=virtio_scsi_lun,json=virtioScsiLun,proto3" json:"virtio_scsi_lun,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Virtio Scsi Lun.

func (*UpdateVirtioScsiLunRequest) Descriptor deprecated 

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

Deprecated: Use UpdateVirtioScsiLunRequest.ProtoReflect.Descriptor instead.

func (*UpdateVirtioScsiLunRequest) GetAllowMissing 

func (x *UpdateVirtioScsiLunRequest) GetAllowMissing() bool

func (*UpdateVirtioScsiLunRequest) GetUpdateMask 

func (x *UpdateVirtioScsiLunRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateVirtioScsiLunRequest) GetVirtioScsiLun 

func (x *UpdateVirtioScsiLunRequest) GetVirtioScsiLun() *VirtioScsiLun

func (*UpdateVirtioScsiLunRequest) ProtoMessage 

func (*UpdateVirtioScsiLunRequest) ProtoMessage()

func (*UpdateVirtioScsiLunRequest) ProtoReflect 

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

func (*UpdateVirtioScsiLunRequest) Reset 

func (x *UpdateVirtioScsiLunRequest) Reset()

func (*UpdateVirtioScsiLunRequest) String 

func (x *UpdateVirtioScsiLunRequest) String() string

type UpdateVirtioScsiTargetRequest 

type UpdateVirtioScsiTargetRequest struct {

	// The object's `name` field is used to identify the object to be updated.
	VirtioScsiTarget *VirtioScsiTarget `protobuf:"bytes,1,opt,name=virtio_scsi_target,json=virtioScsiTarget,proto3" json:"virtio_scsi_target,omitempty"`
	// The list of fields to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the object is not found, a new object will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

Represents a request to update an Virtio Scsi Target.

func (*UpdateVirtioScsiTargetRequest) Descriptor deprecated 

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

Deprecated: Use UpdateVirtioScsiTargetRequest.ProtoReflect.Descriptor instead.

func (*UpdateVirtioScsiTargetRequest) GetAllowMissing 

func (x *UpdateVirtioScsiTargetRequest) GetAllowMissing() bool

func (*UpdateVirtioScsiTargetRequest) GetUpdateMask 

func (x *UpdateVirtioScsiTargetRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateVirtioScsiTargetRequest) GetVirtioScsiTarget 

func (x *UpdateVirtioScsiTargetRequest) GetVirtioScsiTarget() *VirtioScsiTarget

func (*UpdateVirtioScsiTargetRequest) ProtoMessage 

func (*UpdateVirtioScsiTargetRequest) ProtoMessage()

func (*UpdateVirtioScsiTargetRequest) ProtoReflect 

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

func (*UpdateVirtioScsiTargetRequest) Reset 

func (x *UpdateVirtioScsiTargetRequest) Reset()

func (*UpdateVirtioScsiTargetRequest) String 

func (x *UpdateVirtioScsiTargetRequest) String() string

type VirtioBlk 

type VirtioBlk struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The PCI endpoint where this device should appear
	PcieId *PciEndpoint `protobuf:"bytes,2,opt,name=pcie_id,json=pcieId,proto3" json:"pcie_id,omitempty"`
	// The back/middle-end volume to back this controller
	VolumeNameRef string `protobuf:"bytes,3,opt,name=volume_name_ref,json=volumeNameRef,proto3" json:"volume_name_ref,omitempty"`
	// Max IO queue pairs
	MaxIoQps int64 `protobuf:"varint,4,opt,name=max_io_qps,json=maxIoQps,proto3" json:"max_io_qps,omitempty"`
	// min QoS limits for the virtio-blk device
	MinLimit *QosLimit `protobuf:"bytes,5,opt,name=min_limit,json=minLimit,proto3" json:"min_limit,omitempty"`
	// max QoS limits for the virtio-blk device
	MaxLimit *QosLimit `protobuf:"bytes,6,opt,name=max_limit,json=maxLimit,proto3" json:"max_limit,omitempty"`
	// contains filtered or unexported fields
}

Represnts emulated Virtio-blk device

func (*VirtioBlk) Descriptor deprecated 

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

Deprecated: Use VirtioBlk.ProtoReflect.Descriptor instead.

func (*VirtioBlk) GetMaxIoQps 

func (x *VirtioBlk) GetMaxIoQps() int64

func (*VirtioBlk) GetMaxLimit 

func (x *VirtioBlk) GetMaxLimit() *QosLimit

func (*VirtioBlk) GetMinLimit 

func (x *VirtioBlk) GetMinLimit() *QosLimit

func (*VirtioBlk) GetName 

func (x *VirtioBlk) GetName() string

func (*VirtioBlk) GetPcieId 

func (x *VirtioBlk) GetPcieId() *PciEndpoint

func (*VirtioBlk) GetVolumeNameRef 

func (x *VirtioBlk) GetVolumeNameRef() string

func (*VirtioBlk) ProtoMessage 

func (*VirtioBlk) ProtoMessage()

func (*VirtioBlk) ProtoReflect 

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

func (*VirtioBlk) Reset 

func (x *VirtioBlk) Reset()

func (*VirtioBlk) String 

func (x *VirtioBlk) String() string

type VirtioScsiController 

type VirtioScsiController struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// xPU's PCI ID for the controller
	PcieId *PciEndpoint `protobuf:"bytes,2,opt,name=pcie_id,json=pcieId,proto3" json:"pcie_id,omitempty"`
	// min QoS limits for the controller
	MinLimit *QosLimit `protobuf:"bytes,3,opt,name=min_limit,json=minLimit,proto3" json:"min_limit,omitempty"`
	// max QoS limits for the controller
	MaxLimit *QosLimit `protobuf:"bytes,4,opt,name=max_limit,json=maxLimit,proto3" json:"max_limit,omitempty"`
	// contains filtered or unexported fields
}

Represents Scsi Controller

func (*VirtioScsiController) Descriptor deprecated 

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

Deprecated: Use VirtioScsiController.ProtoReflect.Descriptor instead.

func (*VirtioScsiController) GetMaxLimit 

func (x *VirtioScsiController) GetMaxLimit() *QosLimit

func (*VirtioScsiController) GetMinLimit 

func (x *VirtioScsiController) GetMinLimit() *QosLimit

func (*VirtioScsiController) GetName 

func (x *VirtioScsiController) GetName() string

func (*VirtioScsiController) GetPcieId 

func (x *VirtioScsiController) GetPcieId() *PciEndpoint

func (*VirtioScsiController) ProtoMessage 

func (*VirtioScsiController) ProtoMessage()

func (*VirtioScsiController) ProtoReflect 

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

func (*VirtioScsiController) Reset 

func (x *VirtioScsiController) Reset()

func (*VirtioScsiController) String 

func (x *VirtioScsiController) String() string

type VirtioScsiLun 

type VirtioScsiLun struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The target that this LUN is in
	TargetNameRef string `protobuf:"bytes,2,opt,name=target_name_ref,json=targetNameRef,proto3" json:"target_name_ref,omitempty"`
	// The middle/back-end volume for this LLUN
	VolumeNameRef string `protobuf:"bytes,3,opt,name=volume_name_ref,json=volumeNameRef,proto3" json:"volume_name_ref,omitempty"`
	// contains filtered or unexported fields
}

Represents Scsi Lun

func (*VirtioScsiLun) Descriptor deprecated 

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

Deprecated: Use VirtioScsiLun.ProtoReflect.Descriptor instead.

func (*VirtioScsiLun) GetName 

func (x *VirtioScsiLun) GetName() string

func (*VirtioScsiLun) GetTargetNameRef 

func (x *VirtioScsiLun) GetTargetNameRef() string

func (*VirtioScsiLun) GetVolumeNameRef 

func (x *VirtioScsiLun) GetVolumeNameRef() string

func (*VirtioScsiLun) ProtoMessage 

func (*VirtioScsiLun) ProtoMessage()

func (*VirtioScsiLun) ProtoReflect 

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

func (*VirtioScsiLun) Reset 

func (x *VirtioScsiLun) Reset()

func (*VirtioScsiLun) String 

func (x *VirtioScsiLun) String() string

type VirtioScsiTarget 

type VirtioScsiTarget struct {

	// name is an opaque object handle that is not user settable.
	// name will be returned with created object
	// user can only set {resource}_id on the Create request object
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// maximum LUNs within a target
	MaxLuns int32 `protobuf:"varint,2,opt,name=max_luns,json=maxLuns,proto3" json:"max_luns,omitempty"`
	// contains filtered or unexported fields
}

Represents Scsi Target

func (*VirtioScsiTarget) Descriptor deprecated 

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

Deprecated: Use VirtioScsiTarget.ProtoReflect.Descriptor instead.

func (*VirtioScsiTarget) GetMaxLuns 

func (x *VirtioScsiTarget) GetMaxLuns() int32

func (*VirtioScsiTarget) GetName 

func (x *VirtioScsiTarget) GetName() string

func (*VirtioScsiTarget) ProtoMessage 

func (*VirtioScsiTarget) ProtoMessage()

func (*VirtioScsiTarget) ProtoReflect 

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

func (*VirtioScsiTarget) Reset 

func (x *VirtioScsiTarget) Reset()

func (*VirtioScsiTarget) String 

func (x *VirtioScsiTarget) String() string

type VolumeStats 

type VolumeStats struct {

	// Count of read bytes
	ReadBytesCount int32 `protobuf:"varint,1,opt,name=read_bytes_count,json=readBytesCount,proto3" json:"read_bytes_count,omitempty"`
	// Count of read operations
	ReadOpsCount int32 `protobuf:"varint,2,opt,name=read_ops_count,json=readOpsCount,proto3" json:"read_ops_count,omitempty"`
	// Count of written bytes
	WriteBytesCount int32 `protobuf:"varint,3,opt,name=write_bytes_count,json=writeBytesCount,proto3" json:"write_bytes_count,omitempty"`
	// Count of write opeations
	WriteOpsCount int32 `protobuf:"varint,4,opt,name=write_ops_count,json=writeOpsCount,proto3" json:"write_ops_count,omitempty"`
	// Count of unmapped bytes
	UnmapBytesCount int32 `protobuf:"varint,5,opt,name=unmap_bytes_count,json=unmapBytesCount,proto3" json:"unmap_bytes_count,omitempty"`
	// Count of unmap operations
	UnmapOpsCount int32 `protobuf:"varint,6,opt,name=unmap_ops_count,json=unmapOpsCount,proto3" json:"unmap_ops_count,omitempty"`
	// Read latency ticks
	ReadLatencyTicks int32 `protobuf:"varint,7,opt,name=read_latency_ticks,json=readLatencyTicks,proto3" json:"read_latency_ticks,omitempty"`
	// Write latency ticks
	WriteLatencyTicks int32 `protobuf:"varint,8,opt,name=write_latency_ticks,json=writeLatencyTicks,proto3" json:"write_latency_ticks,omitempty"`
	// Unmap latency ticks
	UnmapLatencyTicks int32 `protobuf:"varint,9,opt,name=unmap_latency_ticks,json=unmapLatencyTicks,proto3" json:"unmap_latency_ticks,omitempty"`
	// contains filtered or unexported fields
}

Represents Volume statistics

func (*VolumeStats) Descriptor deprecated 

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

Deprecated: Use VolumeStats.ProtoReflect.Descriptor instead.

func (*VolumeStats) GetReadBytesCount 

func (x *VolumeStats) GetReadBytesCount() int32

func (*VolumeStats) GetReadLatencyTicks 

func (x *VolumeStats) GetReadLatencyTicks() int32

func (*VolumeStats) GetReadOpsCount 

func (x *VolumeStats) GetReadOpsCount() int32

func (*VolumeStats) GetUnmapBytesCount 

func (x *VolumeStats) GetUnmapBytesCount() int32

func (*VolumeStats) GetUnmapLatencyTicks 

func (x *VolumeStats) GetUnmapLatencyTicks() int32

func (*VolumeStats) GetUnmapOpsCount 

func (x *VolumeStats) GetUnmapOpsCount() int32

func (*VolumeStats) GetWriteBytesCount 

func (x *VolumeStats) GetWriteBytesCount() int32

func (*VolumeStats) GetWriteLatencyTicks 

func (x *VolumeStats) GetWriteLatencyTicks() int32

func (*VolumeStats) GetWriteOpsCount 

func (x *VolumeStats) GetWriteOpsCount() int32

func (*VolumeStats) ProtoMessage 

func (*VolumeStats) ProtoMessage()

func (*VolumeStats) ProtoReflect 

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

func (*VolumeStats) Reset 

func (x *VolumeStats) Reset()

func (*VolumeStats) String 

func (x *VolumeStats) 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.