cells-object_grpc.enhanced.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.1.0
// - protoc             v3.18.1
// source: cells-object.proto

package object

import (
	context "context"
	fmt "fmt"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	metadata "google.golang.org/grpc/metadata"
	status "google.golang.org/grpc/status"
	sync "sync"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

var (
	enhancedObjectsEndpointServers     = make(map[string]ObjectsEndpointEnhancedServer)
	enhancedObjectsEndpointServersLock = sync.RWMutex{}
)

type NamedObjectsEndpointServer interface {
	ObjectsEndpointServer
	Name() string
}
type ObjectsEndpointEnhancedServer map[string]NamedObjectsEndpointServer

func (m ObjectsEndpointEnhancedServer) GetMinioConfig(ctx context.Context, r *GetMinioConfigRequest) (*GetMinioConfigResponse, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok || len(md.Get("targetname")) == 0 {
		return nil, status.Errorf(codes.FailedPrecondition, "method GetMinioConfig should have a context")
	}
	enhancedObjectsEndpointServersLock.RLock()
	defer enhancedObjectsEndpointServersLock.RUnlock()
	for _, mm := range m {
		if mm.Name() == md.Get("targetname")[0] {
			return mm.GetMinioConfig(ctx, r)
		}
	}
	return nil, status.Errorf(codes.Unimplemented, "method GetMinioConfig not implemented")
}

func (m ObjectsEndpointEnhancedServer) StorageStats(ctx context.Context, r *StorageStatsRequest) (*StorageStatsResponse, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok || len(md.Get("targetname")) == 0 {
		return nil, status.Errorf(codes.FailedPrecondition, "method StorageStats should have a context")
	}
	enhancedObjectsEndpointServersLock.RLock()
	defer enhancedObjectsEndpointServersLock.RUnlock()
	for _, mm := range m {
		if mm.Name() == md.Get("targetname")[0] {
			return mm.StorageStats(ctx, r)
		}
	}
	return nil, status.Errorf(codes.Unimplemented, "method StorageStats not implemented")
}
func (m ObjectsEndpointEnhancedServer) mustEmbedUnimplementedObjectsEndpointServer() {}
func RegisterObjectsEndpointEnhancedServer(s grpc.ServiceRegistrar, srv NamedObjectsEndpointServer) {
	enhancedObjectsEndpointServersLock.Lock()
	defer enhancedObjectsEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedObjectsEndpointServers[addr]
	if !ok {
		m = ObjectsEndpointEnhancedServer{}
		enhancedObjectsEndpointServers[addr] = m
		RegisterObjectsEndpointServer(s, m)
	}
	m[srv.Name()] = srv
}
func DeregisterObjectsEndpointEnhancedServer(s grpc.ServiceRegistrar, name string) {
	enhancedObjectsEndpointServersLock.Lock()
	defer enhancedObjectsEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedObjectsEndpointServers[addr]
	if !ok {
		return
	}
	delete(m, name)
}

var (
	enhancedDataSourceEndpointServers     = make(map[string]DataSourceEndpointEnhancedServer)
	enhancedDataSourceEndpointServersLock = sync.RWMutex{}
)

type NamedDataSourceEndpointServer interface {
	DataSourceEndpointServer
	Name() string
}
type DataSourceEndpointEnhancedServer map[string]NamedDataSourceEndpointServer

func (m DataSourceEndpointEnhancedServer) GetDataSourceConfig(ctx context.Context, r *GetDataSourceConfigRequest) (*GetDataSourceConfigResponse, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok || len(md.Get("targetname")) == 0 {
		return nil, status.Errorf(codes.FailedPrecondition, "method GetDataSourceConfig should have a context")
	}
	enhancedDataSourceEndpointServersLock.RLock()
	defer enhancedDataSourceEndpointServersLock.RUnlock()
	for _, mm := range m {
		if mm.Name() == md.Get("targetname")[0] {
			return mm.GetDataSourceConfig(ctx, r)
		}
	}
	return nil, status.Errorf(codes.Unimplemented, "method GetDataSourceConfig not implemented")
}
func (m DataSourceEndpointEnhancedServer) mustEmbedUnimplementedDataSourceEndpointServer() {}
func RegisterDataSourceEndpointEnhancedServer(s grpc.ServiceRegistrar, srv NamedDataSourceEndpointServer) {
	enhancedDataSourceEndpointServersLock.Lock()
	defer enhancedDataSourceEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedDataSourceEndpointServers[addr]
	if !ok {
		m = DataSourceEndpointEnhancedServer{}
		enhancedDataSourceEndpointServers[addr] = m
		RegisterDataSourceEndpointServer(s, m)
	}
	m[srv.Name()] = srv
}
func DeregisterDataSourceEndpointEnhancedServer(s grpc.ServiceRegistrar, name string) {
	enhancedDataSourceEndpointServersLock.Lock()
	defer enhancedDataSourceEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedDataSourceEndpointServers[addr]
	if !ok {
		return
	}
	delete(m, name)
}

var (
	enhancedResourceCleanerEndpointServers     = make(map[string]ResourceCleanerEndpointEnhancedServer)
	enhancedResourceCleanerEndpointServersLock = sync.RWMutex{}
)

type NamedResourceCleanerEndpointServer interface {
	ResourceCleanerEndpointServer
	Name() string
}
type ResourceCleanerEndpointEnhancedServer map[string]NamedResourceCleanerEndpointServer

func (m ResourceCleanerEndpointEnhancedServer) CleanResourcesBeforeDelete(ctx context.Context, r *CleanResourcesRequest) (*CleanResourcesResponse, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok || len(md.Get("targetname")) == 0 {
		return nil, status.Errorf(codes.FailedPrecondition, "method CleanResourcesBeforeDelete should have a context")
	}
	enhancedResourceCleanerEndpointServersLock.RLock()
	defer enhancedResourceCleanerEndpointServersLock.RUnlock()
	for _, mm := range m {
		if mm.Name() == md.Get("targetname")[0] {
			return mm.CleanResourcesBeforeDelete(ctx, r)
		}
	}
	return nil, status.Errorf(codes.Unimplemented, "method CleanResourcesBeforeDelete not implemented")
}
func (m ResourceCleanerEndpointEnhancedServer) mustEmbedUnimplementedResourceCleanerEndpointServer() {
}
func RegisterResourceCleanerEndpointEnhancedServer(s grpc.ServiceRegistrar, srv NamedResourceCleanerEndpointServer) {
	enhancedResourceCleanerEndpointServersLock.Lock()
	defer enhancedResourceCleanerEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedResourceCleanerEndpointServers[addr]
	if !ok {
		m = ResourceCleanerEndpointEnhancedServer{}
		enhancedResourceCleanerEndpointServers[addr] = m
		RegisterResourceCleanerEndpointServer(s, m)
	}
	m[srv.Name()] = srv
}
func DeregisterResourceCleanerEndpointEnhancedServer(s grpc.ServiceRegistrar, name string) {
	enhancedResourceCleanerEndpointServersLock.Lock()
	defer enhancedResourceCleanerEndpointServersLock.Unlock()
	addr := fmt.Sprintf("%p", s)
	m, ok := enhancedResourceCleanerEndpointServers[addr]
	if !ok {
		return
	}
	delete(m, name)
}